SiDetElementsRoadMaker_xk.h

Go to the documentation of this file.

// -*- C++ -*-
 
/*
  Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
*/
 
 
//  Header file for class SiDetElementsRoadMaker_xk
// Version 1.0 3/10/2004 I.Gavrilenko
 
#ifndef SiDetElementsRoadMaker_xk_H
#define SiDetElementsRoadMaker_xk_H
 
#include "InDetRecToolInterfaces/ISiDetElementsRoadMaker.h"
#include "AthenaBaseComps/AthAlgTool.h"
 
#include "AthenaKernel/SlotSpecificObj.h"
#include "SiDetElementsRoadTool_xk/SiDetElementsLayer_xk.h"
#include "SiDetElementsRoadTool_xk/SiDetElementsLayerVectors_xk.h"
#include "StoreGate/ReadCondHandleKey.h"
#include "StoreGate/ReadCondHandle.h"
#include "TrkExInterfaces/IPropagator.h"
#include "TrkGeometry/MagneticFieldProperties.h"
#include "TrkSurfaces/CylinderBounds.h"
 
#include "GaudiKernel/ToolHandle.h"
 
// MagField cache
#include "MagFieldConditions/AtlasFieldCacheCondObj.h"
#include "MagFieldElements/AtlasFieldCache.h"
 
#include <atomic>
#include <iosfwd>
#include <list>
#include <deque>
#include <vector>
#include <array>
 
class MsgStream;
 
namespace InDet{
 
  class SiDetElementRoadMakerData_xk; 
 
  class SiDetElementsRoadMaker_xk final: 
    public extends<AthAlgTool, ISiDetElementsRoadMaker>
  {
    // Public methods:
      
  public:
      
 
    SiDetElementsRoadMaker_xk
      (const std::string&, const std::string&, const IInterface*);
    virtual ~SiDetElementsRoadMaker_xk() = default;
    virtual StatusCode initialize() override;
    virtual StatusCode finalize() override;
 
    virtual void detElementsRoad
      (std::deque<Amg::Vector3D>& globalPositions, 
       std::vector<const InDetDD::SiDetectorElement*>& Road,
       bool testDirection,
       SiDetElementRoadMakerData_xk & roadMakerData,
       const EventContext& ctx) const override;
 
 
    virtual void detElementsRoad
      (const EventContext& ctx,
       MagField::AtlasFieldCache& fieldCache,
       const Trk::TrackParameters& Tp,
       Trk::PropDirection direction,
       std::vector<const InDetDD::SiDetectorElement*>& Road,
       SiDetElementRoadMakerData_xk & roadMakerData) const override;
 
 
    MsgStream&    dump(MsgStream   & out) const override;
    std::ostream& dump(std::ostream& out) const override;
 
  private:
      
    // Protected Data
 
 
    PublicToolHandle<Trk::IPropagator> m_proptool{this, "PropagatorTool",
        "Trk::RungeKuttaPropagator/InDetPropagator", "Propagator tool"};
 
 
    SG::ReadCondHandleKey<SiDetElementsLayerVectors_xk> m_layerVecKey{this, "LayerVecKey",
        "SiDetElementsLayerVectors_xk", "Key of SiDetElementsLayerVectors_xk"};
    SG::ReadCondHandleKey<AtlasFieldCacheCondObj> m_fieldCondObjInputKey{this, "AtlasFieldCacheCondObj", "fieldCondObj",
        "Name of the Magnetic Field conditions object key"}; // Necessary only for dumpConditions method
 
 
    BooleanProperty m_usePIX{this, "usePixel", true};
    BooleanProperty m_useSCT{this, "useSCT", true};
    FloatProperty m_width{this, "RoadWidth", 20., "Width of the road"};
    DoubleProperty m_step{this, "MaxStep", 40., "Max step allowed"};
    StringProperty m_pix{this, "PixManagerLocation", "Pixel", "PIX manager location"};
    StringProperty m_sct{this, "SCTManagerLocation", "SCT", "SCT manager location"};
    StringProperty m_fieldmode{this, "MagneticFieldMode", "MapSolenoid", "Mode of magnetic field"};
    BooleanProperty m_ITkGeometry{this, "ITkGeometry", false};
 
 
    Trk::CylinderBounds                  m_bounds{};
    Trk::MagneticFieldMode               m_fieldModeEnum{Trk::FullField};
    int                                  m_outputlevel{};
 
    // Methods
 
    void computeBounds();
    static float stepToDetElement(const InDetDD::SiDetectorElement*&,
                           Amg::Vector3D&, Amg::Vector3D&) ;
 
    Trk::CylinderBounds getBound(MagField::AtlasFieldCache& fieldCache,
                                 const Trk::TrackParameters&) const;
 
    MsgStream& dumpConditions(MsgStream& out) const;
 
    inline
    const SiDetElementsLayerVectors_xk *getLayers(const EventContext& ctx) const {
       SG::ReadCondHandle<SiDetElementsLayerVectors_xk> layerVec(m_layerVecKey,ctx);
       if (not layerVec.isValid()) {
          ATH_MSG_ERROR("Failed to get " << m_layerVecKey.key());
       }
       return layerVec.cptr();
    }
    static void bookUsageTracker(InDet::SiDetElementRoadMakerData_xk & data, const SiDetElementsLayerVectors_xk &layers) ;
 
  };
 
  MsgStream&    operator << (MsgStream&   , const SiDetElementsRoadMaker_xk&);
  std::ostream& operator << (std::ostream&, const SiDetElementsRoadMaker_xk&); 
 
} // end of name space
 
#endif // SiDetElementsRoadMaker_xk_H