MixingEventSelector.h

Go to the documentation of this file.

/* -*- C++ -*- */
 
/*
  Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef ATHENASERVICES_MIXINGEVENTSELECTOR_H
#define ATHENASERVICES_MIXINGEVENTSELECTOR_H
 
#include "CxxUtils/checker_macros.h"
ATLAS_NO_CHECK_FILE_THREAD_SAFETY;  // non-MT EventSelector
 
#include <cassert>
#include <memory>
#include <vector>
 
#include "AthenaBaseComps/AthService.h"
#include "AthenaKernel/IAddressProvider.h"
#include "AthenaKernel/IAthenaSelectorTool.h"
#include "AthenaKernel/IAtRndmGenSvc.h"
 
#include "GaudiKernel/ServiceHandle.h"
#include "GaudiKernel/IEvtSelector.h"
#include "GaudiKernel/IConverter.h"
#include "GaudiKernel/ToolHandle.h"
#include "GaudiKernel/StatusCode.h"
#include "Gaudi/Property.h" /*StringArrayProperty*/
 
class ISvcLocator;
 
class MixingEventIterator;
 
class StoreGateSvc;
 
namespace CLHEP {
  class RandFlat;
}
 

class MixingEventSelector 
  : public extends<AthService, IEvtSelector, IConverter, IAddressProvider>
{
public:
  struct Context : public IEvtSelector::Context {
    virtual ~Context() {}
    virtual void* identifier() const {
      return (void*)0;
    }
  } ;


  virtual StatusCode next(IEvtSelector::Context& refCtxt) const override;
  virtual StatusCode createAddress(const IEvtSelector::Context& refCtxt,
                                   IOpaqueAddress*&) const override;
 
  virtual StatusCode createContext(IEvtSelector::Context*& refpCtxt) const override;
  virtual StatusCode last(IEvtSelector::Context&) const override;
  virtual StatusCode next(IEvtSelector::Context&, int) const override;
  virtual StatusCode previous(IEvtSelector::Context&) const override;
  virtual StatusCode previous(IEvtSelector::Context&,int) const override;
  virtual StatusCode rewind(IEvtSelector::Context& refCtxt) const override;
  virtual StatusCode releaseContext(IEvtSelector::Context*& refCtxt) const override;
  virtual StatusCode resetCriteria(const std::string& cr,IEvtSelector::Context& c) const override;


  virtual StatusCode preLoadAddresses(StoreID::type  storeID ,
                      IAddressProvider::tadList& tads  ) override;
  virtual StatusCode loadAddresses(StoreID::type  storeID ,
                                   IAddressProvider::tadList& tads  ) override;
  virtual StatusCode updateAddress(StoreID::type  storeID ,
                   SG::TransientAddress*  tad,
                                   const EventContext& ctx) override;
 
  

  virtual const CLID& objType() const override;
  virtual long repSvcType() const override;
  virtual StatusCode createObj(IOpaqueAddress* pAddress, DataObject*& refpObject) override;
 
  // The rest of these are dummies.
  virtual StatusCode setDataProvider(IDataProviderSvc* pService) override;
  virtual SmartIF<IDataProviderSvc>& dataProvider() const override;
  virtual StatusCode setConversionSvc(IConversionSvc* pService) override;
  virtual SmartIF<IConversionSvc>& conversionSvc()    const override;
  virtual StatusCode setAddressCreator(IAddressCreator* creator) override;
  virtual SmartIF<IAddressCreator>& addressCreator()    const override;
  virtual StatusCode fillObjRefs(IOpaqueAddress* pAddress, DataObject* pObject) override;
  virtual StatusCode updateObj(IOpaqueAddress* pAddress, DataObject* refpObject) override;
  virtual StatusCode updateObjRefs(IOpaqueAddress* pAddress, DataObject* pObject) override;
  virtual StatusCode createRep(DataObject* pObject, IOpaqueAddress*& refpAddress) override;
  virtual StatusCode fillRepRefs(IOpaqueAddress* pAddress, DataObject* pObject) override;
  virtual StatusCode updateRep(IOpaqueAddress* pAddress, DataObject* pObject)  override;
  virtual StatusCode updateRepRefs(IOpaqueAddress* pAddress, DataObject* pObject) override;
 


  virtual StatusCode initialize() override;
  virtual StatusCode finalize() override;

  void setUpTriggerList(Gaudi::Details::PropertyBase& trigList); 
  void decodeTrigger(const std::string & triggDescr);


  MixingEventSelector(const std::string& name, ISvcLocator* svc);
  virtual ~MixingEventSelector();
 
private:
  bool validTrigger() const { return (m_trigList.end()!=m_pCurrentTrigger);}


  Gaudi::Property<std::string> m_statusFileName{this, "StreamStatusFileName", {},
    "Name of the file recording the last event used and how many were available for each stream. Default is to produce no file."};
 
  Gaudi::Property<std::vector<std::string>> m_triggerListProp{this, "TriggerList", {}, &MixingEventSelector::setUpTriggerList,
    "List of triggers (streams) to be used. Format is SelectorType/SelectorName:firstEventToUse:lastEventToUse. "
    "One assumes events are consecutively numbered."};
 
  Gaudi::Property<int> m_outputRunNumber{this, "OutputRunNumber", 123456789};
 
  Gaudi::Property<std::vector<unsigned long>> m_eventNumbers{this, "EventNumbers", {},
    "List of event numbers to be used for output stream. If list empty or not long enough, event numbers are "
    "assigned consucutively after last one in list."};
 
  Gaudi::Property<std::string> m_mergedEventInfoKey{this, "MergedEventInfoKey", "MergedEventInfo",
    "StoreGate key for output (merged) event info object. Default is MergedEventInfo"};
 
  Gaudi::Property<std::string> m_randomStreamName{this, "RndmStreamName", "MixingEventSelectorStream",
    "IAtRndmGenSvc stream used as engine for our random distributions"};
 
  ToolHandleArray<IAthenaSelectorTool> m_helperTools{this, "HelperTools", {},
    "Collection of selector tools"};
 
  ServiceHandle<IAtRndmGenSvc> m_atRndmSvc{this, "RndmGenSvc", "AtRndmGenSvc",
    "IAtRndmGenSvc controlling the order with which events are takes from streams"};

 

  class Trigger {
  private:
    IEvtSelector* m_pSelector;
    unsigned int m_firstEvent;
    unsigned int m_toRead;
    unsigned int m_todo;
    mutable unsigned int m_reads;
    mutable IEvtSelector::Context* m_current;
 
  public:
    Trigger(IEvtSelector* pSel, 
        //IEvtSelector::Context* pContext,
        unsigned int firstEvt, unsigned int lastEvt);
 
    unsigned int todo() const { return m_todo; }
    unsigned int toRead() const { return m_toRead; }
    unsigned int read() const { return m_reads; }
    bool done() const;
 
    StatusCode next() const;
    StatusCode previous() const;
    StatusCode createAddress(IOpaqueAddress*&) const;
    StatusCode createContext(IEvtSelector::Context*& pCtxt) const;
 
    bool operator == (const Trigger& rhs) const {
      return ( m_pSelector == rhs.m_pSelector ); 
    }
    bool operator != (const Trigger& rhs) const {
      return ( m_pSelector != rhs.m_pSelector ); 
    }
    bool operator < (const Trigger& rhs) const {
      return ( m_todo < rhs.m_todo || 
          ((m_todo == rhs.m_todo) &&  (m_pSelector < rhs.m_pSelector)) ); 
    }
 
    const std::string& name() const {
      return dynamic_cast<IService&>(selector()).name(); 
    }
    std::string toString() const ;
 
  private:
    IEvtSelector::Context& currentContext() const; //throws GaudiException
    IEvtSelector& selector() const {
      assert( m_pSelector );
      return *m_pSelector;
    }
 
  };

  class TriggerList {
  private:
    std::vector<Trigger> m_trigs;
    std::vector<unsigned int> m_rangeEnd;
    unsigned int m_todo;
  public:
    TriggerList() : m_trigs(), m_rangeEnd(), m_todo(0) {}
    typedef std::vector<Trigger>::const_iterator const_iterator;
    typedef std::vector<Trigger>::iterator iterator;
    bool add(const Trigger&);  
    bool remove(iterator); 
    iterator begin() { return m_trigs.begin(); }
    iterator end() { return m_trigs.end(); }
    const_iterator begin() const { return m_trigs.begin(); }
    const_iterator end() const { return m_trigs.end(); }
    bool empty() const { return m_trigs.empty(); }
    iterator elementInRange(unsigned int); 
    unsigned int todo() const { return m_todo; }
    std::string toString() const;
  };
 
  mutable TriggerList m_trigList; 



  TriggerList::iterator setCurrentTrigger() const;  
  mutable TriggerList::iterator m_pCurrentTrigger;  
  TriggerList::iterator currentTrigger() const;     



  unsigned long getEventNo() const;
  mutable unsigned long m_eventPos{0};       
  ServiceHandle<StoreGateSvc> m_pEventStore;
  std::unique_ptr<CLHEP::RandFlat> m_chooseRangeRand;
 
};
#endif // ATHENASERVICES_MIXINGEVENTSELECTOR_H