Conditions algorithm for luminosity data. More...

#include <LuminosityCondAlg.h>

Inheritance diagram for LuminosityCondAlg:

Collaboration diagram for LuminosityCondAlg:

Public Member Functions
virtual StatusCode	initialize () override
	Gaudi initialize method. More...

virtual StatusCode	execute (const EventContext &ctx) const override
	Algorithm execute method. More...

virtual bool	isReEntrant () const override final

	AthReentrantAlgorithm (const std::string &name, ISvcLocator *pSvcLocator)
	Forward base class ctor. More...

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

virtual bool	isClonable () const override
	Specify if the algorithm is clonable. More...

virtual unsigned int	cardinality () const override
	Cardinality (Maximum number of clones that can exist) special value 0 means that algorithm is reentrant. More...

virtual StatusCode	sysExecute (const EventContext &ctx) override
	Execute an algorithm. More...

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

virtual bool	filterPassed (const EventContext &ctx) const

virtual void	setFilterPassed (bool state, const EventContext &ctx) const

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
StatusCode	updateAvgLumi (const CondAttrListCollection &lumiData, LuminosityCondData &lumi, unsigned int &preferredChannel, unsigned int &calibChannel, const coral::Blob *&bunchInstLumiBlob) const
	Unpack luminosity data from the attribute list. More...

StatusCode	updatePerBunchLumi (const EventContext &ctx, const coral::Blob *bunchInstLumiBlob, unsigned int preferredChannel, unsigned int calibChannel, SG::WriteCondHandle< LuminosityCondData > &wHdl, LuminosityCondData &lumi) const
	Fill in per-bunch luminosity data. More...

StatusCode	updateMuToLumi (const EventContext &ctx, unsigned int calibChannel, SG::WriteCondHandle< LuminosityCondData > &wHdl, LuminosityCondData &lumi, bool &isValid) const
	Fill in mu-to-lumi calibration. More...

StatusCode	updatePerBunchLumiRun2 (const coral::Blob &bunchInstLumiBlob, unsigned int preferredChannel, LuminosityCondData &lumi) const
	Fill in per-bunch luminosity data, run 2 and later. More...

StatusCode	updatePerBunchLumiRun1 (const EventContext &ctx, unsigned int preferredChannel, SG::WriteCondHandle< LuminosityCondData > &wHdl, LuminosityCondData &lumi) const
	Fill in per-bunch luminosity data, run 1. More...

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
Gaudi::Property< unsigned long >	m_lumiChannel { this, "LumiChannelNumber", 0, "Luminosity channel to read. 0 means to determine from the data." }

Gaudi::Property< unsigned long >	m_calibBackupChannel { this, "CalibBackupChannel", 112, "Backup channel in case calibChannel doesn't exist in online calibration folder" }

Gaudi::Property< bool >	m_skipInvalid { this, "SkipInvalid", true, "Flag to control whether invalid data is skipped: True (default), returning a zero luminosity; false, returning available luminosity values anyway." }

Gaudi::Property< bool >	m_expectInvalid { this, "ExpectInvalid", false, "Flag to control printouts when invalid data are encountered: True suppresses messages, False (default) leaves them in" }

Gaudi::Property< bool >	m_isMC { this, "IsMC", false, "Set to true when running on MC instead of data" }

Gaudi::Property< float >	m_muToLumi { this, "MCMuToLumi", 0.140569, "mu to lumi conversion factor in MC (80 mb/LHC rev freq)" }

SG::ReadCondHandleKey< CondAttrListCollection >	m_luminosityFolderInputKey

SG::ReadCondHandleKey< OnlineLumiCalibrationCondData >	m_onlineLumiCalibrationInputKey

SG::ReadCondHandleKey< BunchLumisCondData >	m_bunchLumisInputKey

SG::ReadCondHandleKey< BunchGroupCondData >	m_bunchGroupInputKey

SG::ReadCondHandleKey< FillParamsCondData >	m_fillParamsInputKey

SG::ReadCondHandleKey< AthenaAttributeList >	m_mcDigitizationInputKey

SG::ReadHandleKey< xAOD::EventInfo >	m_eventInfoKey { this, "EventInfoKey", "EventInfo", "EventInfo key, used to read in simulated mu in MC" }

SG::ReadDecorHandleKey< xAOD::EventInfo >	m_actualMuKey

SG::ReadDecorHandleKey< xAOD::EventInfo >	m_averageMuKey

SG::WriteCondHandleKey< LuminosityCondData >	m_luminosityOutputKey
	Output conditions object. More...

DataObjIDColl	m_extendedExtraObjects
	Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks. More...

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

Conditions algorithm for luminosity data.

Definition at line 33 of file LuminosityCondAlg.h.

Member Typedef Documentation

◆ StoreGateSvc_t

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

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Member Function Documentation

◆ AthReentrantAlgorithm()

AthReentrantAlgorithm::AthReentrantAlgorithm

Forward base class ctor.

Definition at line 90 of file AthReentrantAlgorithm.cxx.

                                                                          :
   ::AthCommonDataStore<AthCommonMsg<Gaudi::Algorithm>>   ( name, pSvcLocator )
 {
  
   // Set up to run AthAlgorithmDHUpdate in sysInitialize before
   // merging depedency lists.  This extends the output dependency
   // list with any symlinks implied by inheritance relations.
   m_updateDataHandles =
     std::make_unique<AthenaBaseComps::AthAlgorithmDHUpdate>
     (m_extendedExtraObjects,
      std::move (m_updateDataHandles));
 }

◆ cardinality()

unsigned int AthReentrantAlgorithm::cardinality ( ) const

overridevirtualinherited

Cardinality (Maximum number of clones that can exist) special value 0 means that algorithm is reentrant.

Override this to return 0 for reentrant algorithms.

Definition at line 55 of file AthReentrantAlgorithm.cxx.

 {
   return 0;
 }

◆ declareGaudiProperty() [1/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Gaudi::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< Gaudi::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< Gaudi::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< Gaudi::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< Gaudi::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< Gaudi::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< Gaudi::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< Gaudi::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< Gaudi::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< Gaudi::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< Gaudi::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< Gaudi::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< Gaudi::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 LuminosityCondAlg::execute ( const EventContext & ctx ) const

overridevirtual

Algorithm execute method.

Parameters

ctx	Event Context.

Definition at line 84 of file LuminosityCondAlg.cxx.

 {
   auto lumi = std::make_unique<LuminosityCondData>();
   SG::WriteCondHandle<LuminosityCondData> luminosityCondData
     (m_luminosityOutputKey, ctx);
  
   if (m_isMC) {
     // MC case.
     const auto* eventinfo = SG::get(m_eventInfoKey, ctx);
     // define a range for this one LB with one second validity
     EventIDRange range = EventIDRange(EventIDBase(eventinfo->runNumber(),
                                      EventIDBase::UNDEFEVT,
                                      eventinfo->timeStamp(),
                                      eventinfo->timeStampNSOffset(),
                                      eventinfo->lumiBlock()),
                          EventIDBase(eventinfo->runNumber(),
                                      EventIDBase::UNDEFEVT,
                                      eventinfo->timeStamp()+1,
                                      eventinfo->timeStampNSOffset(),
                                      eventinfo->lumiBlock()+1));
  
  
     SG::ReadCondHandle<AthenaAttributeList> digitizationFolder(m_mcDigitizationInputKey, ctx);
     luminosityCondData.addDependency(range);
     
     const float avgMu = eventinfo->averageInteractionsPerCrossing();
     const auto& attr = (**digitizationFolder)[std::string("BeamIntensityPattern")];
     const std::string& sbunches = attr.data<std::string>();
     std::vector<float> bunchpattern = tokenize(sbunches);
     
     if (bunchpattern.size() != LuminosityCondData::TOTAL_LHC_BCIDS) {
       ATH_MSG_ERROR("Decoding MC bunch structure failed, improper number of LHC BCIDs");
       bunchpattern = std::vector<float>(LuminosityCondData::TOTAL_LHC_BCIDS, 1.);
     }
  
     float totintensity = 0.;
     for (size_t i = 0; i < bunchpattern.size(); ++i) {
       totintensity += bunchpattern[i];
       bunchpattern[i] *= (avgMu*m_muToLumi);
     }
  
     lumi->setLbAverageInteractionsPerCrossing(avgMu);
     lumi->setLbAverageLuminosity(totintensity*avgMu*m_muToLumi);
     lumi->setLbLuminosityPerBCIDVector(std::move(bunchpattern));
     lumi->setMuToLumi(m_muToLumi);
   }
   else {
     SG::ReadCondHandle<CondAttrListCollection> luminosityFolder
       (m_luminosityFolderInputKey, ctx);
     luminosityCondData.addDependency(luminosityFolder);
  
     unsigned int preferredChannel;
     unsigned int calibChannel;
     const coral::Blob* bunchInstLumiBlob = nullptr;
     ATH_CHECK( updateAvgLumi (**luminosityFolder,
                               *lumi,
                               preferredChannel,
                               calibChannel,
                               bunchInstLumiBlob) );
  
     ATH_CHECK( updatePerBunchLumi (ctx,
                                    bunchInstLumiBlob,
                                    preferredChannel,
                                    calibChannel,
                                    luminosityCondData,
                                    *lumi) );
   }
  
   
   ATH_CHECK( luminosityCondData.record (std::move (lumi)) );
   return StatusCode::SUCCESS;
 }

◆ extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< Gaudi::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 & AthReentrantAlgorithm::extraOutputDeps ( ) const

overridevirtualinherited

Return the list of extra output dependencies.

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

Definition at line 79 of file AthReentrantAlgorithm.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();
 }

◆ filterPassed()

virtual bool AthReentrantAlgorithm::filterPassed ( const EventContext & ctx ) const

inlinevirtualinherited

Definition at line 135 of file AthReentrantAlgorithm.h.

                                                            {
     return execState( ctx ).filterPassed();
   }

◆ initialize()

StatusCode LuminosityCondAlg::initialize ( )

overridevirtual

Gaudi initialize method.

Definition at line 57 of file LuminosityCondAlg.cxx.

 {
   ATH_CHECK( m_luminosityOutputKey.initialize() );
  
   // May be empty if configured for MC.
   ATH_CHECK( m_onlineLumiCalibrationInputKey.initialize(!m_isMC) );
   ATH_CHECK( m_luminosityFolderInputKey.initialize(!m_isMC) );
  
   // May be empty if configured for data.
   ATH_CHECK( m_mcDigitizationInputKey.initialize(m_isMC) );
   ATH_CHECK( m_eventInfoKey.initialize(m_isMC) );
   ATH_CHECK( m_actualMuKey.initialize(m_isMC) );
   ATH_CHECK( m_averageMuKey.initialize(m_isMC) );
  
   // Only used for run1.
   ATH_CHECK( m_bunchLumisInputKey.initialize(SG::AllowEmpty) );
   ATH_CHECK( m_bunchGroupInputKey.initialize(SG::AllowEmpty) );
   ATH_CHECK( m_fillParamsInputKey.initialize(SG::AllowEmpty) );
   return StatusCode::SUCCESS;
 }

◆ inputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< Gaudi::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.

◆ isClonable()

bool AthReentrantAlgorithm::isClonable ( ) const

overridevirtualinherited

Specify if the algorithm is clonable.

Reentrant algorithms are clonable.

Reimplemented in Simulation::BeamEffectsAlg, InDet::SiTrackerSpacePointFinder, InDet::SCT_Clusterization, InDet::SiSPSeededTrackFinder, SCTRawDataProvider, InDet::GNNSeedingTrackMaker, SCT_PrepDataToxAOD, RoIBResultToxAOD, SCT_CablingCondAlgFromCoraCool, SCT_ReadCalibDataTestAlg, SCT_CablingCondAlgFromText, InDet::SiSPGNNTrackMaker, SCT_ReadCalibChipDataTestAlg, SCT_TestCablingAlg, SCT_ConfigurationConditionsTestAlg, ITkPixelCablingAlg, ITkStripCablingAlg, SCTEventFlagWriter, SCT_ConditionsSummaryTestAlg, SCT_ModuleVetoTestAlg, SCT_MonitorConditionsTestAlg, SCT_LinkMaskingTestAlg, SCT_MajorityConditionsTestAlg, SCT_RODVetoTestAlg, SCT_SensorsTestAlg, SCT_TdaqEnabledTestAlg, SCT_SiliconConditionsTestAlg, SCTSiLorentzAngleTestAlg, SCT_ByteStreamErrorsTestAlg, SCT_ConditionsParameterTestAlg, SCT_FlaggedConditionTestAlg, SCT_StripVetoTestAlg, SCT_RawDataToxAOD, and SCTSiPropertiesTestAlg.

Definition at line 44 of file AthReentrantAlgorithm.cxx.

 {
   // Reentrant algorithms are clonable.
   return true;
 }

◆ isReEntrant()

virtual bool LuminosityCondAlg::isReEntrant ( ) const

inlinefinaloverridevirtual

Definition at line 47 of file LuminosityCondAlg.h.

47 { return false; }

◆ msg() [1/2]

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

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                 {
     return this->msgStream();
   }

◆ msg() [2/2]

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

inlineinherited

Definition at line 27 of file AthCommonMsg.h.

                                                   {
     return this->msgStream(lvl);
   }

◆ msgLvl()

bool AthCommonMsg< Gaudi::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< Gaudi::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< Gaudi::Algorithm > >::renounce ( T & h )

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

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

◆ renounceArray()

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

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                           {
     handlesArray.renounce();
   }

◆ setFilterPassed()

virtual void AthReentrantAlgorithm::setFilterPassed	(	bool	state,
		const EventContext &	ctx
	)		const

inlinevirtualinherited

Definition at line 139 of file AthReentrantAlgorithm.h.

                                                                             {
     execState( ctx ).setFilterPassed( state );
   }

◆ sysExecute()

StatusCode AthReentrantAlgorithm::sysExecute ( const EventContext & ctx )

overridevirtualinherited

Execute an algorithm.

We override this in order to work around an issue with the Algorithm base class storing the event context in a member variable that can cause crashes in MT jobs.

Definition at line 67 of file AthReentrantAlgorithm.cxx.

 {
   return Gaudi::Algorithm::sysExecute (ctx);
 }

◆ sysInitialize()

StatusCode AthReentrantAlgorithm::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< Gaudi::Algorithm > >.

Reimplemented in InputMakerBase, and HypoBase.

Definition at line 96 of file AthReentrantAlgorithm.cxx.

                                                 {
   StatusCode sc=AthCommonDataStore<AthCommonMsg<Gaudi::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< Gaudi::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.

◆ updateAvgLumi()

StatusCode LuminosityCondAlg::updateAvgLumi	(	const CondAttrListCollection &	lumiData,
		LuminosityCondData &	lumi,
		unsigned int &	preferredChannel,
		unsigned int &	calibChannel,
		const coral::Blob *&	bunchInstLumiBlob
	)		const

private

Unpack luminosity data from the attribute list.

Parameters

lumiData	Input luminosity data.
lumi	Output luminosity data being filled.
preferredChannel[out]	Preferred luminosity channel to use.
calibChannel[out]	Calibration luminosity channel to use.
bunchInstLumiBlob[out]	Packed per-bunch luminosity data. Set to null for Run 1.

Unpacks luminosity data from the attribute list. Fills in the average luminosity fields in lumi, and determines the luminosity channels to use. For Run 2 and later, returns the packed luminosity data.

Definition at line 173 of file LuminosityCondAlg.cxx.

 {
   preferredChannel = 0;
   calibChannel = 0;
   bunchInstLumiBlob = nullptr;
  
   const coral::AttributeList& attrList = lumiData.attributeList (m_lumiChannel);
   if (attrList.size() == 0 || attrList["Valid"].isNull()) {
     ATH_MSG_DEBUG ("Can't find luminosity information for channel " << m_lumiChannel);
     return StatusCode::SUCCESS;
   }
  
   if (msgLvl (MSG::DEBUG)) {
     std::ostringstream attrStr1;
     attrList.toOutputStream( attrStr1 );
     ATH_MSG_DEBUG( "ChanNum " << m_lumiChannel << " Attribute list "
                    << attrStr1.str() );
   }
  
   // Check data availability
   if (attrList["LBAvInstLumi"].isNull() || attrList["LBAvEvtsPerBX"].isNull()) {
     ATH_MSG_ERROR( " NULL Luminosity information in database " );
     return StatusCode::FAILURE;
   }
  
   // Check validity (don't bother continuing if invalid)
   uint32_t valid = attrList["Valid"].data<cool::UInt32>();
   lumi.setLbAverageValid (valid);
   if (valid & 0x01) {
     if (m_skipInvalid) {
       if (!m_expectInvalid) {
         ATH_MSG_INFO( " Invalid LB Average luminosity ... set lumi to 0" );
       }
       return StatusCode::SUCCESS;
     } else {
       ATH_MSG_DEBUG( " Invalid LB Average luminosity ... continuing because skipInvalid == FALSE" );
     }
   }
  
   // Get preferred channel (needed for per-BCID calculation)
   if (m_lumiChannel == 0u) {
  
     // Check if we have a payload for this (Run2 only)      
     bool hasAlgorithmID = false;
     for (coral::AttributeList::const_iterator attr = attrList.begin();
      attr != attrList.end(); ++attr) {
       if (attr->specification().name() == "AlgorithmID") {
     hasAlgorithmID = true;
     break;
       }
     }
  
     if (hasAlgorithmID) {
       // In Run2, channel 0 should be good.  Leave as is
       preferredChannel = m_lumiChannel;
       calibChannel = attrList["AlgorithmID"].data<cool::UInt32>();
  
     } else {
       // In Run1, we need to recalculate from the actual channel number
       preferredChannel = (valid >> 22);
       calibChannel = preferredChannel;
     }
  
   } else {
     preferredChannel = m_lumiChannel;
     calibChannel = m_lumiChannel;
   }
  
   float LBAvInstLumi = attrList["LBAvInstLumi"].data<cool::Float>();   // Lumi
   float LBAvEvtsPerBX = attrList["LBAvEvtsPerBX"].data<cool::Float>(); // Mu
  
   // Check (and protect for NaN
   if ( std::isnan (LBAvInstLumi) ) {
     ATH_MSG_WARNING( " Luminosity is not a number.. " << LBAvInstLumi << "  ... set it to 0 " );
     LBAvInstLumi=0.;
   }
  
   if ( std::isnan (LBAvEvtsPerBX) ) {
     ATH_MSG_WARNING( " Luminosity is not a number.. " << LBAvEvtsPerBX << "  ... set it to 0 " );
     LBAvEvtsPerBX=0.;
   }
  
   lumi.setLbAverageLuminosity (LBAvInstLumi);
   lumi.setLbAverageInteractionsPerCrossing (LBAvEvtsPerBX);
  
   // Check validity of per-BCID luminosity (will issue warning in recalcPerBCIDLumi
   int perBcidValid = ((valid&0x3ff)/10) % 10;
   if ((perBcidValid > 0) && m_skipInvalid) {
     return StatusCode::SUCCESS;
   }
  
   // Also save per-BCID blob if it exists
   for (coral::AttributeList::const_iterator attr = attrList.begin();
        attr != attrList.end(); ++attr)
   {
     if (attr->specification().name() == "BunchInstLumi") {
       if (!attrList["BunchInstLumi"].isNull())
     bunchInstLumiBlob = &attrList["BunchInstLumi"].data<coral::Blob>();
       break;
     }
   }
  
   return StatusCode::SUCCESS;
 }

◆ updateMuToLumi()

StatusCode LuminosityCondAlg::updateMuToLumi	(	const EventContext &	ctx,
		unsigned int	calibChannel,
		SG::WriteCondHandle< LuminosityCondData > &	wHdl,
		LuminosityCondData &	lumi,
		bool &	isValid
	)		const

private

Fill in mu-to-lumi calibration.

Parameters

ctx	Event context.
calibChannel	Calibration luminosity channel to use.
wHdl	WriteCondHandle of the conditions data being filled. Range is updated if needed.
lumi	Output luminosity data being filled.
isValid	Set to false if data are not valid.
ctx	Event context.
calibChannel	Calibration luminosity channel to use.
wHdl	WriteHandle of the conditions data being filled. Range is updated if needed.
lumi	Output luminosity data being filled.
isValid	Set to false if data are not valid.

Definition at line 347 of file LuminosityCondAlg.cxx.

 {
   SG::ReadCondHandle<OnlineLumiCalibrationCondData> onlineLumiCalibration
     ( m_onlineLumiCalibrationInputKey, ctx );
   wHdl.addDependency(onlineLumiCalibration);
  
   // This is the only correct way to do this!
   // The division below gives average mu (over all bunches) to total lumi
   float muToLumi = onlineLumiCalibration->getMuToLumi (calibChannel);
  
   // Check if this is reasonable
   if (muToLumi < 0.) {
     ATH_MSG_WARNING(" Found muToLumi = " << muToLumi << " for channel " << calibChannel << ". Try backup channel..." );
     muToLumi = onlineLumiCalibration->getMuToLumi(m_calibBackupChannel);
     ATH_MSG_WARNING(" Found muToLumi = " << muToLumi << " for backup channel " << m_calibBackupChannel);
   }
  
   lumi.setMuToLumi (muToLumi);
  
   // Check validity
   isValid = true;
   int perBcidValid = ((lumi.lbAverageValid()&0x3ff)/10) % 10;
   if ((lumi.lbAverageValid() & 0x03) || (perBcidValid > 0)) {  // Skip if either per-BCID or LBAv is invalid
     isValid = false;
     if (m_skipInvalid) {
       ATH_MSG_WARNING( " Invalid per-BCID luminosity found: "
                        << lumi.lbAverageValid() << "!" );
       return StatusCode::SUCCESS;
     } else {
       ATH_MSG_WARNING( " Invalid per-BCID luminosity found: "
                        << lumi.lbAverageValid()
                        << " continuing because skipInvalid == FALSE" );
     }
   }
  
   // Now check muToLumi and report depending upon whether lumi is valid or not
   if (muToLumi < 0.) {
     if (isValid) {
       ATH_MSG_ERROR(" Found invalid muToLumi = " << muToLumi << " for backup channel " << m_calibBackupChannel << "!");
     } else {
       ATH_MSG_WARNING(" Found invalid muToLumi = " << muToLumi << " for backup channel " << m_calibBackupChannel << "!");
     }
  
     // Don't keep negative values
     muToLumi = 0.;
     lumi.setMuToLumi (muToLumi);
   }
  
   ATH_MSG_DEBUG(" Found muToLumi = " << muToLumi << " for channel "
                 << calibChannel );
  
   return StatusCode::SUCCESS;
 }

◆ updatePerBunchLumi()

StatusCode LuminosityCondAlg::updatePerBunchLumi	(	const EventContext &	ctx,
		const coral::Blob *	bunchInstLumiBlob,
		unsigned int	preferredChannel,
		unsigned int	calibChannel,
		SG::WriteCondHandle< LuminosityCondData > &	wHdl,
		LuminosityCondData &	lumi
	)		const

private

Fill in per-bunch luminosity data.

Parameters

ctx	Event context.
bunchInstLumiBlob	Packed per-bunch luminosity data. Null for Run 1.
preferredChannel	Preferred luminosity channel to use.
calibChannel	Calibration luminosity channel to use.
wHdl	WriteCondHandle conditions data being filled. Range is updated if needed.
lumi	Output luminosity data being filled.
ctx	Event context.
bunchInstLumiBlob	Packed per-bunch luminosity data. Null for Run 1.
preferredChannel	Preferred luminosity channel to use.
calibChannel	Calibration luminosity channel to use.
wHdl	WriteHandle of the conditions data being filled. Range is updated if needed.
lumi	Output luminosity data being filled.

Definition at line 296 of file LuminosityCondAlg.cxx.

 {
   if (lumi.lbAverageLuminosity() <= 0.) {
     if (!m_expectInvalid) {
       ATH_MSG_INFO( "LBAvInstLumi is zero or negative in updatePerBunchLumi():"
                        << lumi.lbAverageLuminosity());
      wHdl.addDependency(IOVInfiniteRange::infiniteRunLB());
     }
     return StatusCode::SUCCESS;
   }
   bool isValid = true;
   ATH_CHECK( updateMuToLumi (ctx, calibChannel, wHdl, lumi, isValid) );
  
   // Check here if we want to do this the Run1 way (hard) or the Run2 way (easy)
  
   if (!isValid) {
     // Skip if not valid.
   }
   else if (bunchInstLumiBlob != nullptr) { // Run2 way, easy
     ATH_CHECK( updatePerBunchLumiRun2 (*bunchInstLumiBlob,
                                        preferredChannel,
                                        lumi) );
   }
   else { // Run1 way, hard!
     ATH_CHECK( updatePerBunchLumiRun1 (ctx,
                                        preferredChannel,
                                        wHdl,
                                        lumi) );
   }
  
   ATH_MSG_DEBUG( "finished updatePerBunchLumi() for alg: "
                  << preferredChannel );
   return StatusCode::SUCCESS;
 }

◆ updatePerBunchLumiRun1()

StatusCode LuminosityCondAlg::updatePerBunchLumiRun1	(	const EventContext &	ctx,
		unsigned int	preferredChannel,
		SG::WriteCondHandle< LuminosityCondData > &	wHdl,
		LuminosityCondData &	lumi
	)		const

private

Fill in per-bunch luminosity data, run 1.

Parameters

preferredChannel	Preferred luminosity channel to use.
wHdl	WriteHandle of the conditions data being filled. Range is updated if needed.
lumi	Output luminosity data being filled.
preferredChannel	Preferred luminosity channel to use.
wHdl	WriteHandle of the conditions data being filled.
lumi	Output luminosity data being filled.

Definition at line 480 of file LuminosityCondAlg.cxx.

 {
   ATH_MSG_DEBUG( "starting updatePerBunchLumiRun1() for alg: " << preferredChannel );
     
   if (preferredChannel == 0) {
     return StatusCode::SUCCESS;
   }
  
   // Nothing to do if we don't have the ingredients
   if (m_onlineLumiCalibrationInputKey.empty()) {
     ATH_MSG_DEBUG( "OnlineLumiCalibrationInputKey.empty() is TRUE, skipping..." );
     return StatusCode::SUCCESS;
   }
   if (m_bunchLumisInputKey.empty()) {
     ATH_MSG_DEBUG( "BunchLumisInputKey.empty() is TRUE, skipping..." );
     return StatusCode::SUCCESS;
   }
   if (m_bunchGroupInputKey.empty()) {
     ATH_MSG_DEBUG( "BunchGroupTool.empty() is TRUE, skipping..." );
     return StatusCode::SUCCESS;
   }
   if (m_fillParamsInputKey.empty()) {
     ATH_MSG_DEBUG( "FillParamsInputKey.empty() is TRUE, skipping..." );
     return StatusCode::SUCCESS;
   }
  
   SG::ReadCondHandle<OnlineLumiCalibrationCondData> onlineLumiCalibration
     (m_onlineLumiCalibrationInputKey, ctx);
   wHdl.addDependency(onlineLumiCalibration);
   SG::ReadCondHandle<BunchLumisCondData> bunchLumis (m_bunchLumisInputKey, ctx);
   wHdl.addDependency(bunchLumis);
   SG::ReadCondHandle<BunchGroupCondData> bunchGroup (m_bunchGroupInputKey, ctx);
   wHdl.addDependency(bunchGroup);
   SG::ReadCondHandle<FillParamsCondData> fillParams (m_fillParamsInputKey, ctx);
   wHdl.addDependency(fillParams);
  
   const std::vector<unsigned int>& luminousBunches = fillParams->luminousBunches();
   ATH_MSG_DEBUG( "N LuminousBunches:" << luminousBunches.size() );
  
   // Get the raw data for the preferred channel
   const std::vector<float>& rawLumiVec = bunchLumis->rawLuminosity(preferredChannel);
   if (rawLumiVec.empty()) {
     ATH_MSG_DEBUG( "Empty raw luminosity vector" );
     return StatusCode::SUCCESS;
   }
  
   //
   // Calibration step
   //
     
   //  Here we want to go through and calibrate raw values in the luminous bunches only.
   // This is what the OL adds up, and since these are online calibrations, we want to rescale the total
   // to agree to whatever offline tag we are using.
   std::vector<float> calLumiVec (LuminosityCondData::TOTAL_LHC_BCIDS, 0.);
     
   // Update muToLumi while we are at it (also check that calibration exists)
   float muToLumi = onlineLumiCalibration->getMuToLumi (preferredChannel);
   if (muToLumi <= 0.) {
     ATH_MSG_ERROR( " dont have calibration information for preferred channel "
                    << preferredChannel << "!" );
     return StatusCode::FAILURE;
   }
   lumi.setMuToLumi (muToLumi);
  
   double lumiSum = 0.;
   for (unsigned int bcid : luminousBunches) {
     // Don't waste time on zero lumi 
     if (rawLumiVec.at(bcid) <= 0.) {
       ATH_MSG_DEBUG( "Calibrate BCID " << bcid << " with raw "
                      << rawLumiVec.at(bcid) << " -> skipping" );
       continue;
     }
  
     // Calibrate
     if (!onlineLumiCalibration->calibrateLumi(preferredChannel,
                                               rawLumiVec[bcid],
                                               calLumiVec[bcid]))
     {
       ATH_MSG_DEBUG( "Calibrate BCID " << bcid << " with raw " << rawLumiVec[bcid] << " -> calibration failed!" );
       ATH_MSG_WARNING( "Per-BCID calibration failed for bcid " << bcid << " with raw lumi = " << rawLumiVec[bcid] );
       continue;
     }
       
     lumiSum += calLumiVec[bcid];
       
     ATH_MSG_DEBUG( "Calibrate BCID " << bcid << " with raw " << rawLumiVec[bcid] << " -> " << calLumiVec[bcid] );
   }
  
   // Work out scale factor between offline and online estimate
   float offlineOnlineRatio = 1.;
   if (lumiSum > 0.) offlineOnlineRatio = lumi.lbAverageLuminosity() / lumiSum;
     
   ATH_MSG_DEBUG( " Offline/Online scale factor: " << lumi.lbAverageLuminosity()
                  << " / " << lumiSum << " = " << offlineOnlineRatio );
  
   // Make sure we have values for all BCIDs in the physics bunch group
   for (unsigned int bcid : bunchGroup->bunchGroup (1)) {
     // Don't repeat if value already exists
     if (calLumiVec[bcid] > 0.) continue;
     if (rawLumiVec[bcid] <= 0.) continue;
       
     // Calibrate
     if (!onlineLumiCalibration->calibrateLumi(preferredChannel,
                                               rawLumiVec[bcid],
                                               calLumiVec[bcid]))
     {
       ATH_MSG_DEBUG( " -> Calibration failed!" );
       ATH_MSG_WARNING( "Per-BCID calibration failed for bcid " << bcid
                        << " with raw lumi = " << rawLumiVec[bcid] );
       continue;
     }
   }
  
   // Almost done, now we apply the scale factor to all BCIDs
   for (float& lumi : calLumiVec) {
     lumi *= offlineOnlineRatio;
   }
  
   lumi.setLbLuminosityPerBCIDVector (std::move (calLumiVec));
  
   return StatusCode::SUCCESS;
 }

◆ updatePerBunchLumiRun2()

StatusCode LuminosityCondAlg::updatePerBunchLumiRun2	(	const coral::Blob &	bunchInstLumiBlob,
		unsigned int	preferredChannel,
		LuminosityCondData &	lumi
	)		const

private

Fill in per-bunch luminosity data, run 2 and later.

Parameters

bunchInstLumiBlob	Packed per-bunch luminosity data.
preferredChannel	Preferred luminosity channel to use.
lumi	Output luminosity data being filled.

Definition at line 413 of file LuminosityCondAlg.cxx.

 {
   ATH_MSG_DEBUG( "starting updatePerBunchLumiRun2() for alg: " << preferredChannel );
  
   // Check that the length isn't zero
   if (bunchInstLumiBlob.size() == 0) {
     ATH_MSG_ERROR("BunchInstLumi blob found with zero length!");
     return StatusCode::FAILURE;
   }
  
   // Hardcode the Run2 BLOB decoding (should use CoolLumiUtilities...)
   const uint8_t* ATH_RESTRICT pchar =
     static_cast<const uint8_t*>(bunchInstLumiBlob.startingAddress()); // First byte holds storage size and mode
   unsigned int bss = ((*pchar) % 100) / 10;  // Byte storage size
   unsigned int smod = ((*pchar) % 10);       // Storage mode
   ++pchar;  // Points to next char after header
  
   ATH_MSG_DEBUG( "BunchInstLumi blob found with storage mode " << smod
                  << " and byte storage size " << bss );
  
   // Make sure we have what we think we have
   if (bss != 4 || smod != 1) {
     ATH_MSG_ERROR( "BunchInstLumi blob found with storage mode " << smod << " and byte storage size " << bss << " - Unknown!");
     return StatusCode::FAILURE;
   }
  
   unsigned int nbcids = LuminosityCondData::TOTAL_LHC_BCIDS;
   unsigned int bloblength = bss * nbcids + 1;
  
   if (static_cast<cool::UInt32>(bunchInstLumiBlob.size()) != bloblength) {
     ATH_MSG_ERROR( "BunchRawInstLumi blob found with length"
                    << bunchInstLumiBlob.size() << "in storage mode" << smod
                    <<  ", expecting " << bloblength << "!" );
     return StatusCode::FAILURE;
   }
  
   // Length is correct, read raw data according to packing scheme
   // This is absolute luminosity, so just unpack values into our array
     
   ATH_MSG_DEBUG( "Unpacking lumi value from blob");
   std::vector<float> instLumi (nbcids);
   for (unsigned int i=0; i<nbcids; i++) {
     // Can't use assignment directly because source may be misaligned.
     instLumi[i] = CxxUtils::get_unaligned_float (pchar);
   }
  
   if (msgLvl (MSG::DEBUG)) {
     for (unsigned int i=0; i<nbcids; i++) {
       ATH_MSG_DEBUG( "Bcid: " << i << " Lumi: " << instLumi[i] );
     }
   }
  
   lumi.setLbLuminosityPerBCIDVector (std::move (instLumi));
  
   return StatusCode::SUCCESS;
 }

◆ updateVHKA()

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

SG::ReadDecorHandleKey<xAOD::EventInfo> LuminosityCondAlg::m_actualMuKey

private

Initial value:

{ this, "actualMuKey", "EventInfo.actualInteractionsPerCrossing",

"Decoration for Actual Interaction Per Crossing, for MC" }

Definition at line 184 of file LuminosityCondAlg.h.

◆ m_averageMuKey

SG::ReadDecorHandleKey<xAOD::EventInfo> LuminosityCondAlg::m_averageMuKey

private

Initial value:

{ this, "averageMuKey", "EventInfo.averageInteractionsPerCrossing",

"Decoration for Average Interaction Per Crossing" }

Definition at line 188 of file LuminosityCondAlg.h.

◆ m_bunchGroupInputKey

SG::ReadCondHandleKey<BunchGroupCondData> LuminosityCondAlg::m_bunchGroupInputKey

private

Initial value:

{ this, "BunchGroupInputKey", "",

"Input filled bunch data. Only used for Run 1." }

Definition at line 168 of file LuminosityCondAlg.h.

◆ m_bunchLumisInputKey

SG::ReadCondHandleKey<BunchLumisCondData> LuminosityCondAlg::m_bunchLumisInputKey

private

Initial value:

{ this, "BunchLumisInputKey", "",

"Input raw luminosities. Only used for Run 1." }

Definition at line 164 of file LuminosityCondAlg.h.

◆ m_calibBackupChannel

Gaudi::Property<unsigned long> LuminosityCondAlg::m_calibBackupChannel { this, "CalibBackupChannel", 112, "Backup channel in case calibChannel doesn't exist in online calibration folder" }

private

Definition at line 139 of file LuminosityCondAlg.h.

◆ m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

◆ m_eventInfoKey

SG::ReadHandleKey<xAOD::EventInfo> LuminosityCondAlg::m_eventInfoKey { this, "EventInfoKey", "EventInfo", "EventInfo key, used to read in simulated mu in MC" }

private

Definition at line 181 of file LuminosityCondAlg.h.

◆ m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

◆ m_expectInvalid

Gaudi::Property<bool> LuminosityCondAlg::m_expectInvalid { this, "ExpectInvalid", false, "Flag to control printouts when invalid data are encountered: True suppresses messages, False (default) leaves them in" }

private

Definition at line 145 of file LuminosityCondAlg.h.

◆ m_extendedExtraObjects

DataObjIDColl AthReentrantAlgorithm::m_extendedExtraObjects

privateinherited

Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks.

Empty if no symlinks were found.

Definition at line 153 of file AthReentrantAlgorithm.h.

◆ m_fillParamsInputKey

SG::ReadCondHandleKey<FillParamsCondData> LuminosityCondAlg::m_fillParamsInputKey

private

Initial value:

{ this, "FillParamsInputKey", "",

"Input luminous bunch data. Only used for Run 1." }

Definition at line 172 of file LuminosityCondAlg.h.

◆ m_isMC

Gaudi::Property<bool> LuminosityCondAlg::m_isMC { this, "IsMC", false, "Set to true when running on MC instead of data" }

private

Definition at line 149 of file LuminosityCondAlg.h.

◆ m_lumiChannel

Gaudi::Property<unsigned long> LuminosityCondAlg::m_lumiChannel { this, "LumiChannelNumber", 0, "Luminosity channel to read. 0 means to determine from the data." }

private

Definition at line 136 of file LuminosityCondAlg.h.

◆ m_luminosityFolderInputKey

SG::ReadCondHandleKey<CondAttrListCollection> LuminosityCondAlg::m_luminosityFolderInputKey

private

Initial value:

{ this, "LuminosityFolderInputKey", "/TRIGGER/OFLLUMI/LBLESTOFL",

"Input luminosity COOL folder." }

Definition at line 156 of file LuminosityCondAlg.h.

◆ m_luminosityOutputKey

SG::WriteCondHandleKey<LuminosityCondData> LuminosityCondAlg::m_luminosityOutputKey

private

Initial value:

{ this, "LuminosityOutputKey", "LuminosityCondData",

"Output luminosity data." }

Output conditions object.

Definition at line 193 of file LuminosityCondAlg.h.

◆ m_mcDigitizationInputKey

SG::ReadCondHandleKey<AthenaAttributeList> LuminosityCondAlg::m_mcDigitizationInputKey

private

Initial value:

{ this, "DigitizationFolderInputKey", "/Digitization/Parameters",

"Digitization parameters metadata folder." }

Definition at line 177 of file LuminosityCondAlg.h.

◆ m_muToLumi

Gaudi::Property<float> LuminosityCondAlg::m_muToLumi { this, "MCMuToLumi", 0.140569, "mu to lumi conversion factor in MC (80 mb/LHC rev freq)" }

private

Definition at line 152 of file LuminosityCondAlg.h.

◆ m_onlineLumiCalibrationInputKey

SG::ReadCondHandleKey<OnlineLumiCalibrationCondData> LuminosityCondAlg::m_onlineLumiCalibrationInputKey

private

Initial value:

{ this, "OnlineLumiCalibrationInputKey", "OnlineLumiCalibrationCondData",

"Input luminosity calibration." }

Definition at line 160 of file LuminosityCondAlg.h.

◆ m_skipInvalid

Gaudi::Property<bool> LuminosityCondAlg::m_skipInvalid { this, "SkipInvalid", true, "Flag to control whether invalid data is skipped: True (default), returning a zero luminosity; false, returning available luminosity values anyway." }

private

Definition at line 142 of file LuminosityCondAlg.h.

◆ m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

◆ m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< Gaudi::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

Member Function Documentation

◆ AthReentrantAlgorithm()

◆ cardinality()

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

◆ filterPassed()

◆ initialize()

◆ inputHandles()

◆ isClonable()

◆ isReEntrant()

◆ msg() [1/2]

◆ msg() [2/2]

◆ msgLvl()

◆ outputHandles()

◆ renounce()

◆ renounceArray()

◆ setFilterPassed()

◆ sysExecute()

◆ sysInitialize()

◆ sysStart()

◆ updateAvgLumi()

◆ updateMuToLumi()

◆ updatePerBunchLumi()

◆ updatePerBunchLumiRun1()

◆ updatePerBunchLumiRun2()

◆ updateVHKA()

Member Data Documentation

◆ m_actualMuKey

◆ m_averageMuKey

◆ m_bunchGroupInputKey

◆ m_bunchLumisInputKey

◆ m_calibBackupChannel

◆ m_detStore

◆ m_eventInfoKey

◆ m_evtStore

◆ m_expectInvalid

◆ m_extendedExtraObjects

◆ m_fillParamsInputKey

◆ m_isMC

◆ m_lumiChannel

◆ m_luminosityFolderInputKey

◆ m_luminosityOutputKey

◆ m_mcDigitizationInputKey

◆ m_muToLumi

◆ m_onlineLumiCalibrationInputKey

◆ m_skipInvalid

◆ m_varHandleArraysDeclared

◆ m_vhka