TrackingVolumeHelper.h

Go to the documentation of this file.

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

// TrackingVolumeHelper.h, (c) ATLAS Detector software
 
#ifndef TRKDETDESCRTOOLS_TRACKINGVOLUMEHELPER_H
#define TRKDETDESCRTOOLS_TRACKINGVOLUMEHELPER_H
 
#ifndef TRKDETDESCR_TAKESMALLERBIGGER
#define TRKDETDESCR_TAKESMALLERBIGGER
#define takeSmaller(current, test) current = current < test ? current : test
#define takeBigger(current, test) current = current > test ? current : test
#define takeSmallerBigger(cSmallest, cBiggest, test)                           \
  takeSmaller(cSmallest, test);                                                \
  takeBigger(cBiggest, test)
#endif
// Trk
#include "TrkDetDescrInterfaces/ITrackingVolumeHelper.h"
#include "TrkGeometry/TrackingVolumeManipulator.h"
// Amg
#include "GeoPrimitives/GeoPrimitives.h"
// Gaudi & Athena
#include "AthenaBaseComps/AthAlgTool.h"
#include "GaudiKernel/SystemOfUnits.h"
#include "GaudiKernel/ToolHandle.h"
// STL
#include <algorithm>
#include <fstream>
#include <string>
 
#include "CxxUtils/checker_macros.h"
namespace Trk {
 
class ILayerArrayCreator;
class ITrackingVolumeArrayCreator;
class TrackingVolume;
class VolumeBounds;
class CylinderVolumeBounds;
class Material;
class LayerMaterialProperties;

 
class TrackingVolumeHelper
  : public AthAlgTool
  , public TrackingVolumeManipulator
  , virtual public ITrackingVolumeHelper
{
 
public:
  TrackingVolumeHelper(const std::string&,
                       const std::string&,
                       const IInterface*);

  StatusCode initialize() override;

  void glueTrackingVolumes(TrackingVolume& firstVol,
                           BoundarySurfaceFace firstFace,
                           TrackingVolume& secondVol,
                           BoundarySurfaceFace secondFace,
                           bool buildBoundaryLayer = false) const override;

  void glueTrackingVolumes(TrackingVolume& firstVol,
                           BoundarySurfaceFace firstFace,
                           const std::vector<TrackingVolume*>& secondVolumes,
                           BoundarySurfaceFace secondFace,
                           bool buildBoundaryLayer = false,
                           bool boundaryFaceExchange = false) const override;

  void glueTrackingVolumes(const std::vector<TrackingVolume*>& firstVolumes,
                           BoundarySurfaceFace firstFace,
                           const std::vector<TrackingVolume*>& secondVolumes,
                           BoundarySurfaceFace secondFace,
                           bool buildBoundaryLayer = false,
                           bool boundaryFaceExchange = false) const override;

  std::unique_ptr<Trk::TrackingVolume> glueTrackingVolumeArrays(
      std::shared_ptr<TrackingVolume> firstVol,
      BoundarySurfaceFace firstFace,
      std::shared_ptr<TrackingVolume> secondVol,
      BoundarySurfaceFace secondFace,
      const std::string& name) const override;

  void setInsideTrackingVolume(TrackingVolume& tvol,
                               BoundarySurfaceFace face,
                               TrackingVolume* insidevol) const override;

  void setInsideTrackingVolumeArray(
    TrackingVolume& tvol,
    BoundarySurfaceFace face,
    std::shared_ptr<BinnedArray<TrackingVolume>> insidevolarray) const override;

  void setOutsideTrackingVolume(TrackingVolume& tvol,
                                BoundarySurfaceFace face,
                                TrackingVolume* outsidevol) const override;

  void setOutsideTrackingVolumeArray(
    TrackingVolume& tvol,
    BoundarySurfaceFace face,
    std::shared_ptr<BinnedArray<TrackingVolume>> outsidevolarray) const override;
 
private:
   std::unique_ptr<Trk::LayerMaterialProperties> layerMaterialProperties(const Trk::Surface& sf) const;

  static void fillGlueVolumes(const std::vector<TrackingVolume*>& topLevelVolumes,
                              const std::vector<TrackingVolume*>& envelopeFaceVolumes,
                              BoundarySurfaceFace glueFace,
                              std::vector<Trk::TrackingVolume*>& glueVols);
 
  static void fillGlueVolumes(const std::vector<std::shared_ptr<TrackingVolume>>& topLevelVolumes,
                              const std::vector<std::shared_ptr<TrackingVolume>>& envelopeFaceVolumes,
                              BoundarySurfaceFace glueFace,
                              std::vector<Trk::TrackingVolume*>& glueVols);
 

  void glueTrackingVolumes(const std::vector<std::shared_ptr<TrackingVolume>>& glueVols,
                           BoundarySurfaceFace glueFace,
                           BoundarySurfaceFace secondFace) const;
 
  void glueTrackingVolumes(const std::vector<TrackingVolume*>& glueVols,
                           BoundarySurfaceFace glueFace,
                           BoundarySurfaceFace secondFace) const;
  PublicToolHandle<ILayerArrayCreator>
    m_layerArrayCreator{this, "LayerArrayCreator", "Trk::LayerArrayCreator/LayerArrayCreator"}; 
  ToolHandle<ITrackingVolumeArrayCreator>
    m_trackingVolumeArrayCreator{this, "TrackingVolumeArrayCreator", "Trk::TrackingVolumeArrayCreator/TrackingVolumeArrayCreator"}; 
 
  Gaudi::Property<int> m_barrelLayerBinsZ{this, "BarrelLayerBinsZ", 1};   
  Gaudi::Property<int> m_barrelLayerBinsPhi{this, "BarrelLayerBinsPhi", 1}; 
  Gaudi::Property<int> m_endcapLayerBinsR{this, "EndcapLayerBinsR", 1};   
  Gaudi::Property<int> m_endcapLayerBinsPhi{this, "EndcapLayerBinsPhi", 1}; 
 
  static constexpr double s_layerThickness =
    1. * Gaudi::Units::mm; 
};
 
}
 
#endif