PileUpMergeSvc.h

Go to the documentation of this file.

/* -*- C++ -*- */
 
/*
  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
*/

#ifndef PILEUPTOOLS_PILEUPMERGESVC_H
#define PILEUPTOOLS_PILEUPMERGESVC_H
 
#include "EventInfo/PileUpTimeEventIndex.h"
#include "xAODEventInfo/EventInfo.h"
#include "PileUpTools/IPileUpTool.h"    /* subEventIterator*/
#include "xAODCnvInterfaces/IEventInfoCnvTool.h"
 
#include "AthenaBaseComps/AthService.h"
#include "GaudiKernel/ClassID.h"
#include "Gaudi/Property.h"   /*StringArrayProperty*/
#include "GaudiKernel/StatusCode.h"
#include "GaudiKernel/ServiceHandle.h"
#include "GaudiKernel/ToolHandle.h"
 
#include "AthLinks/DataLink.h"
#include "AthenaKernel/SlotSpecificObj.h"
 
#include "PileUpTools/IPileUpXingFolder.h"
#include "CxxUtils/checker_macros.h"
 
#include <cassert>
 
#include <list>
#include <map>
#include <utility> /*std::pair*/
#include <mutex>
 
class ISvcLocator;
class StoreGateSvc;
class ITriggerTime;
class IToolSvc;
 

 
class PileUpMergeSvc : public AthService {
 
public:
  PileUpMergeSvc(const std::string& name, ISvcLocator* svc);
        
  virtual ~PileUpMergeSvc() {}
 
  virtual StatusCode initialize() override;

  template <typename DATA>
  struct TimedList {
    typedef DATA data_t;
    typedef std::pair<PileUpTimeEventIndex, DataLink<DATA> > value_t;
    typedef std::list<value_t> type;
  };

  template <typename KEY, typename DATA>
  StatusCode 
  retrieveOriginal(const KEY& dataKey, const DATA*& data);
 
  template <typename KEY, typename DATA>
  StatusCode
  retrieveSingleSubEvtData(const KEY& dataKey, const DATA*& data, int bunchXing, SubEventIterator iEvt);

  template <typename KEY, typename TIMEDDATA>
  StatusCode 
  retrieveSubEvtsData(const KEY& dataKey, //orig evt key
              TIMEDDATA& timedData);
 
  template <typename KEY, typename TIMEDDATA>
  StatusCode 
  retrieveSubSetEvtData(const KEY& dataKey, //orig evt key
            TIMEDDATA& timedData, int bunchXing,
            SubEventIterator bSubEvents, SubEventIterator eSubEvents);

  template <typename KEY, typename TIMEDDATA>
  StatusCode 
  retrieveSubEvtsData(const KEY& dataKey, //orig evt key
              TIMEDDATA& timedData, unsigned int& numberOfSimHits);
 
  
//   ///retrieve default DATA objs for all sub-events and attach a time to them
//   template <typename TIMEDDATA>
//   StatusCode 
//   retrieveSubEvtsData(TIMEDDATA& timedData);

  StatusCode clearDataCaches();

  const xAOD::EventInfo* getPileUpEvent( StoreGateSvc* sg,
                                         const std::string& einame ) const;
 
private:
  ServiceHandle<StoreGateSvc> p_overStore;      
  ToolHandleArray<IPileUpXingFolder> m_intervals{this, "Intervals", {},
    "Folders specifying bunch xing intervals for different data objects"};
 
  // Protect against multiple threads trying to make EventInfo
  // for the same slot.
  mutable SG::SlotSpecificObj<std::mutex> m_slotMutex ATLAS_THREAD_SAFE;
 
  template <typename DATA, typename KEY>
  bool isLive(const KEY& key, int iXing);   
  bool isLive(CLID id, const std::string& dataKey, int iXing);
 
  void decodeIntervals();

  class Range {
  public:
    Range() : m_noLimits(true), m_first(0), m_last(0), m_cacheRefreshFrequency(0.0) {}
    Range(int first, int last, double cacheRefreshFrequency) : 
      m_noLimits(false), m_first(first), m_last(last), 
      m_cacheRefreshFrequency(cacheRefreshFrequency) {
      assert(0.0<=m_cacheRefreshFrequency && m_cacheRefreshFrequency<=1.0);
    }
    Range(const Range& rhs) : 
      m_noLimits(rhs.m_noLimits),
      m_first(rhs.m_first), m_last(rhs.m_last),
      m_cacheRefreshFrequency(rhs.m_cacheRefreshFrequency) {}
    Range& operator =(const Range& rhs)
    {
      if (this == &rhs) {return *this;}   // Handle self assignment
      m_noLimits = rhs.m_noLimits;
      m_first = rhs.m_first; 
      m_last = rhs.m_last;
      m_cacheRefreshFrequency = rhs.m_cacheRefreshFrequency;
      return *this;
    }
    bool contains(int xing) const {
      return m_noLimits || (m_first<=xing && xing<=m_last);
    }
    bool doRefresh(float random) const { 
      assert(0.0 <= random && random <= 1.0);
      //      bool result(random < m_cacheRefreshFrequency);
      //      std::cerr << "Range::doRefresh: random " << random 
      //        << " frequency " << m_cacheRefreshFrequency 
      //        << " result " << result << std::endl;
      return ( random < m_cacheRefreshFrequency );
    }
  private:
    bool m_noLimits;
    int m_first, m_last;
    double m_cacheRefreshFrequency;
  };
  typedef std::map<std::pair<CLID, std::string>, Range> RangeContainer;
  RangeContainer m_ranges;
 
  ToolHandle<ITriggerTime> m_pITriggerTime{this, "TriggerTimeTool", "",
    "allows to apply a trigger time offset"};

  BooleanProperty m_returnTimedData{this, "ReturnTimedData", true,
    "determine whether the TimedData returned by retrieveSubEvts have non trivial "
    "PileUpTimeEventIndex. May be set to false for overlay with real events"};
 
  bool doRefresh(const Range& r, int iXing);
 
  //Default name for EventInfo
  StringProperty m_EventInfoKeyName{this, "EventInfoKeyName", "OverlayEvent",
    "default name for EventInfo"};

  ToolHandle< xAODMaker::IEventInfoCnvTool > m_xAODCnvTool{
    this, "xAODCnvTool", "xAODMaker::EventInfoCnvTool/EventInfoCnvTool"};
};
#include "PileUpTools/PileUpMergeSvc.icc"
#endif /* PILEUPTOOLS_PILEUPMERGESVC_H */