CaloRingerReaderUtils.h

Go to the documentation of this file.

// Dear emacs, this is -*- c++ -*-
/*
  Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
*/
#ifndef CALORINGERTOOLS_CALORINGERREADERUTILS_H
#define CALORINGERTOOLS_CALORINGERREADERUTILS_H
 
// STL includes:
#include <string>
#include <memory>
#include <vector>
 
// Athena framework include:
#include "GaudiKernel/ToolHandle.h"
#include "GaudiKernel/IDataHandleHolder.h"
#include "StoreGate/WriteDecorHandle.h"
#include "StoreGate/WriteDecorHandleKey.h"
#include "AthenaBaseComps/AthCheckMacros.h"
#include "AthenaBaseComps/AthMessaging.h"
#include "AthContainers/DataVector.h"
 
// xAOD include:
#include "xAODCaloRings/tools/getCaloRingsDecorator.h"
 
// Interface includes:
#include "CaloRingerTools/ICaloRingsBuilder.h"
 
// Local includes:
#include "RingerKnownParticles.h"
 
// Forward declarations:
class CaloCellContainer;
class IMessageSvc;
 
namespace Ringer {
 
class BuildCaloRingsFctorBase : public AthMessaging {
 
  protected:
    BuildCaloRingsFctorBase(
        ToolHandle<ICaloRingsBuilder> &builder,
        IMessageSvc* msgSvc,
        const std::string& name):
          AthMessaging(msgSvc, name),
          m_builder(builder),
          m_part_counter(0),
          m_part_size(0),
          m_crContH(nullptr),
          m_rsContH(nullptr)
      {;}
 
 
    ToolHandle<ICaloRingsBuilder> &m_builder;
    size_t m_part_counter;
    size_t m_part_size;
 
 
    StatusCode prepareToLoopFor( std::size_t nParticles );
 
    void incrementCounter() { ++m_part_counter; }
 
    void checkRelease();
 
    virtual ~BuildCaloRingsFctorBase(){;}
 
  private:
    SG::WriteHandle<xAOD::CaloRingsContainer>* m_crContH;
    SG::WriteHandle<xAOD::RingSetContainer>* m_rsContH;
 
};
 
template< typename container_t >
class BuildCaloRingsFctor : public BuildCaloRingsFctorBase
{
  public:
    typedef typename container_t::base_value_type particle_t;
    typedef typename SG::WriteDecorHandle< container_t, xAOD::CaloRingsLinks >
      decor_t;
 
  private:
    typedef BuildCaloRingsFctorBase base_t;
    // Import base template properties:
    using base_t::m_builder;
    using base_t::m_part_counter;
    using base_t::m_part_size;
 
    using base_t::checkRelease;
 
    static constexpr const char *m_particle_name = Ringer::GetParticleProp<particle_t>::name;
    static constexpr bool m_particle_has_cluster = Ringer::GetParticleProp<particle_t>::hasCluster;
 
    void displayLoopingMessage() const;
 
    SG::WriteDecorHandleKey< container_t > m_decorKey;
 
    decor_t* m_decor{nullptr};
 
  public:
    BuildCaloRingsFctor(
        const std::string &decoContName,
        ToolHandle<ICaloRingsBuilder> &builder,
        IMessageSvc* msgSvc,
        IDataHandleHolder* owningAlg)
    : BuildCaloRingsFctorBase(
        builder,
        msgSvc,
        owningAlg->name()),
      m_decorKey( decoContName + "." + xAOD::caloRingsLinksDecorKey() )
         { m_decorKey.setOwner(owningAlg);}
 
 
    void operator() (const particle_t *part);
 
    StatusCode initialize();
 
    StatusCode prepareToLoopFor( std::size_t nParticles );
 
    void checkRelease();
};
 
} // namespace Ringer
 
#endif // CALORINGERTOOLS_CALORINGERREADERUTILS_H
 
#ifndef INCLUDE_HEADER_ONLY // Use to avoid circular includes:
#include "CaloRingerReaderUtils.icc"
#endif // INCLUDE_HEADER_ONLY