LuminosityCondAlg Class Reference

Conditions algorithm for luminosity data. More...

#include <LuminosityCondAlg.h>

Inheritance diagram for LuminosityCondAlg:

Public Member Functions
virtual StatusCode	initialize () override
	Gaudi initialize method.
virtual StatusCode	execute (const EventContext &ctx) const override
	Algorithm execute method.
virtual bool	isReEntrant () const override
	Avoid scheduling algorithm multiple times.
virtual StatusCode	sysInitialize () override
	Override sysInitialize.
virtual bool	isClonable () const override
	Specify if the algorithm is clonable.
virtual unsigned int	cardinality () const override
	Cardinality (Maximum number of clones that can exist) special value 0 means that algorithm is reentrant.
virtual StatusCode	sysExecute (const EventContext &ctx) override
	Execute an algorithm.
virtual const DataObjIDColl &	extraOutputDeps () const override
	Return the list of extra output dependencies.
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.
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
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.
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.
StatusCode	updateMuToLumi (const EventContext &ctx, unsigned int calibChannel, SG::WriteCondHandle< LuminosityCondData > &wHdl, LuminosityCondData &lumi, bool &isValid) const
	Fill in mu-to-lumi calibration.
StatusCode	updatePerBunchLumiRun2 (const coral::Blob &bunchInstLumiBlob, unsigned int preferredChannel, LuminosityCondData &lumi) const
	Fill in per-bunch luminosity data, run 2 and later.
StatusCode	updatePerBunchLumiRun1 (const EventContext &ctx, unsigned int preferredChannel, SG::WriteCondHandle< LuminosityCondData > &wHdl, LuminosityCondData &lumi) const
	Fill in per-bunch luminosity data, run 1.
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

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< ByteStreamMetadataContainer >	m_byteStreamMetadataKey
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.
DataObjIDColl	m_extendedExtraObjects
	Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks.
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

Conditions algorithm for luminosity data.

Definition at line 35 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

cardinality()

unsigned int AthCommonReentrantAlgorithm< Gaudi::Algorithm >::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 75 of file AthCommonReentrantAlgorithm.cxx.

{
  return 0;
}

declareGaudiProperty()

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

{ return m_detStore; }

evtStore()

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.

{ return m_evtStore; }

execute()

StatusCode LuminosityCondAlg::execute ( const EventContext & ctx ) const

overridevirtual

Algorithm execute method.

Parameters

ctx	Event Context.

Definition at line 90 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));
 
    luminosityCondData.addDependency(range);
 
    const float avgMu = eventinfo->averageInteractionsPerCrossing();
    std::string sbunches;
 
    // Try to read from digitization folder first (traditional source for POOL files)
    bool foundInDigitization = false;
 
    if (!m_mcDigitizationInputKey.empty()) {
      SG::ReadCondHandle<AthenaAttributeList> digitizationFolder(m_mcDigitizationInputKey, ctx);
 
      if (digitizationFolder.isValid()) {
        try {
          const auto& attr = (**digitizationFolder)[std::string("BeamIntensityPattern")];
          sbunches = attr.data<std::string>();
          foundInDigitization = true;
          ATH_MSG_DEBUG("Read BeamIntensityPattern from Digitization folder");
        } catch (const std::exception& e) {
          ATH_MSG_DEBUG("Could not read from Digitization folder: " << e.what());
        }
      }
    }
 
    // Fall back to ByteStream metadata if not found in digitization folder
    if (!foundInDigitization) {
      SG::ReadHandle<ByteStreamMetadataContainer> bsMetadata(m_byteStreamMetadataKey, ctx);
 
      if (bsMetadata.isValid() && !bsMetadata->empty()) {
        const ByteStreamMetadata* metadata = bsMetadata->at(0);
        const std::vector<std::string>& freeStrings = metadata->getFreeMetaDataStrings();
 
        // Look for IOVMeta./Digitization/Parameters= in freeMetaDataStrings
        for (const std::string& str : freeStrings) {
          if (str.starts_with("IOVMeta./Digitization/Parameters=")) {
            // Extract JSON string after the '=' sign
            size_t eqPos = str.find('=');
            if (eqPos != std::string::npos && eqPos + 1 < str.size()) {
              std::string jsonStr = str.substr(eqPos + 1);
 
              try {
                nlohmann::json iovMetadata = nlohmann::json::parse(jsonStr);
 
                // Extract BeamIntensityPattern from the JSON
                // The JSON structure is: {"iovs": [{"attrs": {"chan65535": {"BeamIntensityPattern": "..."}}}]}
                if (iovMetadata.contains("iovs") && iovMetadata["iovs"].is_array() && !iovMetadata["iovs"].empty()) {
                  const auto& firstIov = iovMetadata["iovs"][0];
                  if (firstIov.contains("attrs")) {
                    // Look through all channels for BeamIntensityPattern
                    for (const auto& chanItem : firstIov["attrs"].items()) {
                      const auto& chanAttrs = chanItem.value();
                      if (chanAttrs.contains("BeamIntensityPattern")) {
                        sbunches = chanAttrs["BeamIntensityPattern"].get<std::string>();
                        ATH_MSG_INFO("Read BeamIntensityPattern from ByteStream metadata");
                        break;
                      }
                    }
                    if (!sbunches.empty()) break;
                  }
                }
              } catch (const std::exception& e) {
                ATH_MSG_WARNING("Failed to parse IOV metadata from ByteStream: " << e.what());
              }
            }
          }
        }
      }
 
      if (sbunches.empty()) {
        ATH_MSG_ERROR("Could not read BeamIntensityPattern from either Digitization folder or ByteStream metadata");
      }
    }
 
    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 & AthCommonReentrantAlgorithm< Gaudi::Algorithm >::extraOutputDeps ( ) const

overridevirtualinherited

Return the list of extra output dependencies.

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

Definition at line 94 of file AthCommonReentrantAlgorithm.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 BaseAlg::extraOutputDeps();
}

filterPassed()

virtual bool AthCommonReentrantAlgorithm< Gaudi::Algorithm >::filterPassed ( const EventContext & ctx ) const

inlinevirtualinherited

Definition at line 96 of file AthCommonReentrantAlgorithm.h.

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

initialize()

StatusCode LuminosityCondAlg::initialize ( )

overridevirtual

Gaudi initialize method.

Definition at line 60 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, or for MC ByteStream (will use BS metadata instead).
  ATH_CHECK( m_mcDigitizationInputKey.initialize(m_isMC && !m_mcDigitizationInputKey.empty()) );
  // ByteStream metadata is only used in MC mode, but we initialize with AllowEmpty always
  // since the code may try to access it. For data mode, it will just be unused.
  ATH_CHECK( m_byteStreamMetadataKey.initialize(SG::AllowEmpty) );
  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 AthCommonReentrantAlgorithm< Gaudi::Algorithm >::isClonable ( ) const

overridevirtualinherited

Specify if the algorithm is clonable.

Reentrant algorithms are clonable.

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

Definition at line 68 of file AthCommonReentrantAlgorithm.cxx.

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

isReEntrant()

virtual bool AthCondAlgorithm::isReEntrant ( ) const

inlineoverridevirtualinherited

Avoid scheduling algorithm multiple times.

With multiple concurrent events, conditions objects often expire simultaneously for all slots. To avoid that the scheduler runs the CondAlg in each slot, we declare it as "non-reentrant". This ensures that the conditions objects are only created once.

In case a particular CondAlg should behave differently, it can override this method again and return true.

See also

ATEAM-836

Definition at line 39 of file AthCondAlgorithm.h.

{ return false; }

msg()

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

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

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 AthCommonReentrantAlgorithm< Gaudi::Algorithm >::setFilterPassed ( bool state, const EventContext & ctx ) const

inlinevirtualinherited

Definition at line 100 of file AthCommonReentrantAlgorithm.h.

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

sysExecute()

StatusCode AthCommonReentrantAlgorithm< Gaudi::Algorithm >::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 85 of file AthCommonReentrantAlgorithm.cxx.

{
  return BaseAlg::sysExecute (ctx);
}

sysInitialize()

StatusCode AthCommonReentrantAlgorithm< Gaudi::Algorithm >::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 HypoBase, and InputMakerBase.

Definition at line 61 of file AthCommonReentrantAlgorithm.cxx.

                                                               {
  StatusCode sc=AthCommonDataStore<AthCommonMsg<BaseAlg>>::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 244 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 418 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 367 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 551 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& bclumi : calLumiVec) {
    bclumi *= 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 484 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", m_eventInfoKey, "actualInteractionsPerCrossing",
    "Decoration for Actual Interaction Per Crossing, for MC" }

Definition at line 189 of file LuminosityCondAlg.h.

  { this, "actualMuKey", m_eventInfoKey, "actualInteractionsPerCrossing",
    "Decoration for Actual Interaction Per Crossing, for MC" };

m_averageMuKey

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

private

Initial value:

{ this, "averageMuKey", m_eventInfoKey, "averageInteractionsPerCrossing",
    "Decoration for Average Interaction Per Crossing" }

Definition at line 193 of file LuminosityCondAlg.h.

  { this, "averageMuKey", m_eventInfoKey, "averageInteractionsPerCrossing",
    "Decoration for Average Interaction Per Crossing" };

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 169 of file LuminosityCondAlg.h.

  { this, "BunchGroupInputKey", "",
    "Input filled bunch data.  Only used for Run 1." };

m_bunchLumisInputKey

SG::ReadCondHandleKey<BunchLumisCondData> LuminosityCondAlg::m_bunchLumisInputKey

private

Initial value:

{ this, "BunchLumisInputKey", "",
    "Input raw luminosities.  Only used for Run 1." }

Definition at line 165 of file LuminosityCondAlg.h.

  { this, "BunchLumisInputKey", "",
    "Input raw luminosities.  Only used for Run 1." };

m_byteStreamMetadataKey

SG::ReadHandleKey<ByteStreamMetadataContainer> LuminosityCondAlg::m_byteStreamMetadataKey

private

Initial value:

{ this, "ByteStreamMetadataKey", "",
    "ByteStream metadata (for reading IOV metadata from BS files in MC mode)" }

Definition at line 182 of file LuminosityCondAlg.h.

  { this, "ByteStreamMetadataKey", "",
    "ByteStream metadata (for reading IOV metadata from BS files in MC mode)" };

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 140 of file LuminosityCondAlg.h.

{ this, "CalibBackupChannel", 112, "Backup channel in case calibChannel doesn't exist in online calibration folder" };

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 186 of file LuminosityCondAlg.h.

{ this, "EventInfoKey", "EventInfo", "EventInfo key, used to read in simulated mu in MC" };

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 146 of file LuminosityCondAlg.h.

{ this, "ExpectInvalid", false, "Flag to control printouts when invalid data are encountered: True suppresses messages, False (default) leaves them in" };

m_extendedExtraObjects

DataObjIDColl AthCommonReentrantAlgorithm< Gaudi::Algorithm >::m_extendedExtraObjects

privateinherited

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

Empty if no symlinks were found.

Definition at line 114 of file AthCommonReentrantAlgorithm.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 173 of file LuminosityCondAlg.h.

  { this, "FillParamsInputKey", "",
    "Input luminous bunch data.  Only used for Run 1." };

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 150 of file LuminosityCondAlg.h.

{ this, "IsMC", false, "Set to true when running on MC instead of data" };

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 137 of file LuminosityCondAlg.h.

{ this, "LumiChannelNumber", 0, "Luminosity channel to read.  0 means to determine from the data." };

m_luminosityFolderInputKey

SG::ReadCondHandleKey<CondAttrListCollection> LuminosityCondAlg::m_luminosityFolderInputKey

private

Initial value:

{ this, "LuminosityFolderInputKey", "/TRIGGER/OFLLUMI/LBLESTOFL",
    "Input luminosity COOL folder." }

Definition at line 157 of file LuminosityCondAlg.h.

  { this, "LuminosityFolderInputKey", "/TRIGGER/OFLLUMI/LBLESTOFL",
    "Input luminosity COOL folder." };

m_luminosityOutputKey

SG::WriteCondHandleKey<LuminosityCondData> LuminosityCondAlg::m_luminosityOutputKey

private

Initial value:

{ this, "LuminosityOutputKey", "LuminosityCondData",
    "Output luminosity data." }

Output conditions object.

Definition at line 198 of file LuminosityCondAlg.h.

  { this, "LuminosityOutputKey", "LuminosityCondData",
    "Output luminosity data." };

m_mcDigitizationInputKey

SG::ReadCondHandleKey<AthenaAttributeList> LuminosityCondAlg::m_mcDigitizationInputKey

private

Initial value:

{ this, "DigitizationFolderInputKey", "/Digitization/Parameters",
    "Digitization parameters metadata folder." }

Definition at line 178 of file LuminosityCondAlg.h.

  { this, "DigitizationFolderInputKey", "/Digitization/Parameters",
    "Digitization parameters metadata folder." };

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 153 of file LuminosityCondAlg.h.

{ this, "MCMuToLumi", 0.140569, "mu to lumi conversion factor in MC (80 mb/LHC rev freq)" };

m_onlineLumiCalibrationInputKey

SG::ReadCondHandleKey<OnlineLumiCalibrationCondData> LuminosityCondAlg::m_onlineLumiCalibrationInputKey

private

Initial value:

{ this, "OnlineLumiCalibrationInputKey", "OnlineLumiCalibrationCondData",
    "Input luminosity calibration." }

Definition at line 161 of file LuminosityCondAlg.h.

  { this, "OnlineLumiCalibrationInputKey", "OnlineLumiCalibrationCondData",
    "Input luminosity calibration." };

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 143 of file LuminosityCondAlg.h.

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

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:

• LuminosityCondAlg.h
• LuminosityCondAlg.cxx