#include <CoolInserter.h>

Inheritance 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.
StatusCode	execute ()
	execute function NOTE: This will read all events at once
StatusCode	finalize ()
	finalize functions
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.
virtual const DataObjIDColl &	extraOutputDeps () const override
	Return the list of extra output dependencies.
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard `StoreGateSvc` (event store) Returns (kind of) a pointer to the `StoreGateSvc`.
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard `StoreGateSvc/DetectorStore` Returns (kind of) a pointer to the `StoreGateSvc`.
virtual StatusCode	sysStart () override
	Handle START transition.
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles.
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T, V, H > &t)
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
bool	msgLvl (const MSG::Level lvl) const

Protected Member Functions
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void >	renounce (T &h)
void	extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
	Add StoreName to extra input/output deps as needed.

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
bool	create_folder (const unsigned int &fldr_nr, const bool &is_rt)
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

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", {}}
ServiceHandle< RegionSelectionSvc >	m_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)
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default)
std::vector< SG::VarHandleKeyArray * >	m_vhka
bool	m_varHandleArraysDeclared

Detailed Description

Definition at line 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"),
        m_reg_sel_svc("RegionSelectionSvc", name),
        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()

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

inlineprivateinherited

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

Definition at line 156 of file AthCommonDataStore.h.

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

◆ declareProperty()

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

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

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

◆ detStore()

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

inlineinherited

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

Definition at line 95 of file AthCommonDataStore.h.

95{ return m_detStore; }

AthCommonDataStore< AthCommonMsg< Algorithm > >::m_detStore

StoreGateSvc_t m_detStore

Definition AthCommonDataStore.h:393

◆ evtStore()

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

inlineinherited

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

Definition at line 85 of file AthCommonDataStore.h.

85{ return m_evtStore; }

AthCommonDataStore< AthCommonMsg< Algorithm > >::m_evtStore

StoreGateSvc_t m_evtStore

Definition AthCommonDataStore.h:390

◆ 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(m_reg_sel_svc.retrieve());
 
        // 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()

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

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

◆ msgLvl()

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

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                               {
    return this->msgLevel(lvl);
  }

◆ outputHandles()

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

overridevirtualinherited

Return this algorithm's output handles.

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

◆ renounce()

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

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

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

◆ renounceArray()

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

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                          {
    handlesArray.renounce();
  }

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

Definition at line 66 of file AthAlgorithm.cxx.

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

◆ sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< Algorithm > >::sysStart ( )

overridevirtualinherited

Handle START transition.

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

◆ updateVHKA()

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

inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

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

Member Data Documentation

◆ m_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.

70{this, "CalibrationSources", {}};

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

87 {this, "DetectorManagerKey", "MuonDetectorManager",

88 "Key of input MuonDetectorManager condition data"};

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

84{this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"};

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

ServiceHandle<RegionSelectionSvc> MuonCalib::CoolInserter::m_reg_sel_svc

private

Definition at line 72 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.

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()

◆ declareProperty()

◆ detStore()

◆ evtStore()

◆ execute()

◆ extraDeps_update_handler()

◆ extraOutputDeps()

◆ finalize()

◆ initialize()

◆ inputHandles()

◆ msg()

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

◆ m_rt_created

◆ m_rt_filled

◆ m_rt_folder

◆ m_sid

◆ m_t0_created

◆ m_t0_filled

◆ m_t0_folder

◆ m_tagrt

◆ m_tagt0

◆ m_varHandleArraysDeclared

◆ m_version

◆ m_vhka