CylinderVolumeCreator.h

Go to the documentation of this file.

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

// CylinderVolumeCreator.h, (c) ATLAS Detector software
 
#ifndef TRKDETDESCRTOOLS_CYLINDERVOLUMECREATOR_H
#define TRKDETDESCRTOOLS_CYLINDERVOLUMECREATOR_H
 
 
// Trk
#include "TrkDetDescrInterfaces/ITrackingVolumeCreator.h"
#include "TrkDetDescrInterfaces/ILayerArrayCreator.h"
#include "TrkDetDescrInterfaces/ITrackingVolumeArrayCreator.h"
#include "TrkDetDescrInterfaces/ITrackingVolumeHelper.h"
#include "TrkVolumes/BoundarySurfaceFace.h"
// Amg
#include "GeoPrimitives/GeoPrimitives.h"
// Gaudi & Athena
#include "AthenaBaseComps/AthAlgTool.h"
#include "GaudiKernel/ToolHandle.h"
#include "GaudiKernel/SystemOfUnits.h"
// STL
#include <string>
#include <vector>
 
#include "CxxUtils/checker_macros.h"
namespace Trk {
 
class Layer;
class CylinderLayer;
class DiscLayer;
class TrackingVolume;
class VolumeBounds;
class CylinderVolumeBounds;
class Material;

 
class CylinderVolumeCreator
  : public AthAlgTool
  , virtual public ITrackingVolumeCreator
{
 
public:
  CylinderVolumeCreator(const std::string&,
                        const std::string&,
                        const IInterface*);

  virtual StatusCode initialize() override;

  virtual TrackingVolume* createTrackingVolume(
    const std::vector<Layer*>& layers,
    Material& matprop,
    VolumeBounds* volBounds = 0,
    Amg::Transform3D* transform = 0,
    const std::string& volumeName = "UndefinedVolume",
    BinningType btype = arbitrary) const override final;

  virtual TrackingVolume* createTrackingVolume(
    const std::vector<Layer*>& layers,
    Material& matprop,
    double loc1Min,
    double loc1Max,
    double loc2Min,
    double loc2Max,
    const std::string& volumeName = "UndefinedVolume",
    BinningType btype = arbitrary) const override final;

 virtual TrackingVolume* createGapTrackingVolume ( 
    Material& matprop,
    double rMin,
    double rMax,
    double zMin,
    double zMax,
    unsigned int materialLayers,
    bool cylinder = true,
    const std::string& volumeName = "UndefinedVolume") const override final;

  virtual TrackingVolume* createGapTrackingVolume (
    Material& matprop,
    double rMin,
    double rMax,
    double zMin,
    double zMax,
    const std::vector<double>& layerPositions,
    bool cylinder = true,
    const std::string& volumeName = "UndefinedVolume",
    BinningType btype = arbitrary) const override final;

  virtual TrackingVolume* createContainerTrackingVolume
  (const std::vector<TrackingVolume*>& volumes,
                        const Material& matprop,
                        const std::string& volumeName = "UndefinedVolume",
                        bool buildBoundaryLayers = false,
                        bool replaceBoundaryFace = false) const override final;
 
private:
 
  StatusCode estimateAndCheckDimension(
    const std::vector<Layer*>& layers,
    Trk::CylinderVolumeBounds*& cylBounds,
    Amg::Transform3D*& translation,
    std::vector<CylinderLayer*>& cylLayers,
    std::vector<DiscLayer*>& discLayers,
    double& rMinClean,
    double& rMaxClean,
    double& zMinClean,
    double& zMaxClean,
    BinningType bType = arbitrary) const;

  StatusCode interGlueTrackingVolume
  (TrackingVolume& tVolume,
                        bool rBinned,
                        bool buildBoundaryLayers,
                        bool replaceBoundaryFace = false) const;

  void addFaceVolumes(TrackingVolume& tvol,
                      Trk::BoundarySurfaceFace bsf,
                      std::vector<Trk::TrackingVolume*>& vols) const;

  void glueTrackingVolumes(TrackingVolume& volumeOne,
                           BoundarySurfaceFace faceOne,
                           TrackingVolume& volumeTwo,
                           BoundarySurfaceFace faceTwo,
                           bool buildBoundaryLayers,
                           bool replaceBoundaryFace = false) const;

  CylinderLayer* createCylinderLayer(double z,
                                     double r,
                                     double halflength,
                                     double thickness,
                                     int binsPhi,
                                     int binsZ) const;

  DiscLayer* createDiscLayer(double z,
                             double rMin,
                             double rMax,
                             double thickness,
                             int binsPhi,
                             int binsR) const;
 
  // helper tools
  ToolHandle<ILayerArrayCreator> m_layerArrayCreator
    {this, "LayerArrayCreator", "Trk::LayerArrayCreator/LayerArrayCreator"};

  ToolHandle<ITrackingVolumeArrayCreator> m_trackingVolumeArrayCreator
    {this, "TrackingVolumeArrayCreator",
     "Trk::TrackingVolumeArrayCreator/TrackingVolumeArrayCreator"};

  ToolHandle<ITrackingVolumeHelper> m_trackingVolumeHelper
    {this, "TrackingVolumeHelper",
     "Trk::TrackingVolumeHelper/TrackingVolumeHelper"};
 
  Gaudi::Property<double> m_passiveLayerThickness
    {this, "PassiveLayerThickness", 1*Gaudi::Units::mm,
     "thickness of passive layers"};
  Gaudi::Property<int> m_passiveLayerPhiBins
    {this, "PassiveLayerBinsPhi", 1, "bins in phi for the passive layer"};
  Gaudi::Property<int> m_passiveLayerRzBins
    {this, "PassiveLayerBinsRZ", 100, "bins in r/z for the passive layer"};
};
}
 
#endif