CylinderVolumeCreator.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2024 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 "TrkVolumes/BoundarySurfaceFace.h"
// Amg
#include "GeoPrimitives/GeoPrimitives.h"
// Gaudi & Athena
#include "AthenaBaseComps/AthAlgTool.h"
#include "GaudiKernel/ToolHandle.h"
// STL
#include <string>
#include <vector>
 
#include "CxxUtils/checker_macros.h"
namespace Trk {
 
class ILayerArrayCreator;
class ITrackingVolumeArrayCreator;
class ITrackingVolumeHelper;
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*);
  ~CylinderVolumeCreator();

  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;
  ToolHandle<ITrackingVolumeArrayCreator> m_trackingVolumeArrayCreator;
  ToolHandle<ITrackingVolumeHelper> m_trackingVolumeHelper;
 
  double m_passiveLayerThickness; 
  int m_passiveLayerPhiBins;      
  int m_passiveLayerRzBins;       
};
}
 
#endif