HGTD_TrackingGeometryBuilderCond Class Reference

#include <HGTD_TrackingGeometryBuilderCond.h>

Inheritance diagram for HGTD_TrackingGeometryBuilderCond:

Collaboration diagram for HGTD_TrackingGeometryBuilderCond:

Public Member Functions
	HGTD_TrackingGeometryBuilderCond (const std::string &, const std::string &, const IInterface *)
	Constructor.
virtual	~HGTD_TrackingGeometryBuilderCond ()
	Destructor.
virtual StatusCode	initialize () override
	AlgTool initailize method.
virtual std::unique_ptr< Trk::TrackingGeometry >	trackingGeometry (const EventContext &ctx, Trk::TrackingVolume *innerVol, SG::WriteCondHandle< Trk::TrackingGeometry > &whandle) const override
	TrackingGeometry Interface method.
virtual Trk::GeometrySignature	geometrySignature () const override
	The unique signature.

Private Attributes
ServiceHandle< IEnvelopeDefSvc >	m_enclosingEnvelopeSvc
	Service to handle the envelope definition.
ToolHandle< Trk::ILayerBuilderCond >	m_layerBuilder
	Helper tools for the geometry building.
ToolHandle< Trk::ITrackingVolumeCreator >	m_trackingVolumeCreator
	Helper Tool to create TrackingVolumes.
bool	m_indexStaticLayers
	configurations for the layer builder
bool	m_buildBoundaryLayers
	create boundary layers
bool	m_replaceJointBoundaries
	run with replacement of all joint boundaries
int	m_layerBinningType
	binning type for layers
unsigned int	m_colorCodeConfig
	Color code for layers.

Detailed Description

Definition at line 31 of file HGTD_TrackingGeometryBuilderCond.h.

Constructor & Destructor Documentation

HGTD_TrackingGeometryBuilderCond()

HGTD_TrackingGeometryBuilderCond::HGTD_TrackingGeometryBuilderCond	(	const std::string &	t,
		const std::string &	n,
		const IInterface *	p )

Constructor.

Definition at line 31 of file HGTD_TrackingGeometryBuilderCond.cxx.

                                                                                                                              :
  base_class(t,n,p),
  m_enclosingEnvelopeSvc("AtlasEnvelopeDefSvc", n),
  m_trackingVolumeCreator("Trk::CylinderVolumeCreator/CylinderVolumeCreator"),
  m_indexStaticLayers(true),
  m_buildBoundaryLayers(true),
  m_replaceJointBoundaries(true),
  m_layerBinningType(2),
  m_colorCodeConfig(3)
{
  // envelope definition service
  declareProperty("EnvelopeDefinitionSvc",            m_enclosingEnvelopeSvc );
  declareProperty("LayerBuilder",                     m_layerBuilder);
  declareProperty("TrackingVolumeCreator",            m_trackingVolumeCreator);
 
  declareProperty("IndexStaticLayers",                m_indexStaticLayers);
  declareProperty("BuildBoundaryLayers",              m_buildBoundaryLayers);
  declareProperty("ReplaceAllJointBoundaries",        m_replaceJointBoundaries);
  declareProperty("LayerBinningType",                 m_layerBinningType);
  declareProperty("ColorCode",                        m_colorCodeConfig);
 
}

~HGTD_TrackingGeometryBuilderCond()

HGTD_TrackingGeometryBuilderCond::~HGTD_TrackingGeometryBuilderCond ( )

virtualdefault

Destructor.

Member Function Documentation

geometrySignature()

virtual Trk::GeometrySignature HGTD_TrackingGeometryBuilderCond::geometrySignature ( ) const

inlineoverridevirtual

The unique signature.

Definition at line 52 of file HGTD_TrackingGeometryBuilderCond.h.

{ return Trk::HGTD; }

initialize()

StatusCode HGTD_TrackingGeometryBuilderCond::initialize ( )

overridevirtual

AlgTool initailize method.

Definition at line 60 of file HGTD_TrackingGeometryBuilderCond.cxx.

{
  // retrieve envelope definition service
  ATH_CHECK(m_enclosingEnvelopeSvc.retrieve());
 
  // retrieve the layer provider
  ATH_CHECK(m_layerBuilder.retrieve());
 
  // retrieve the volume creator
  ATH_CHECK(m_trackingVolumeCreator.retrieve());
 
  ATH_MSG_INFO( "initialize() succesful" );
  return StatusCode::SUCCESS;
}

trackingGeometry()

std::unique_ptr< Trk::TrackingGeometry > HGTD_TrackingGeometryBuilderCond::trackingGeometry ( const EventContext & ctx, Trk::TrackingVolume * innerVol, SG::WriteCondHandle< Trk::TrackingGeometry > & whandle ) const

overridevirtual

TrackingGeometry Interface method.

Definition at line 76 of file HGTD_TrackingGeometryBuilderCond.cxx.

{
 
  ATH_MSG_VERBOSE( "Starting to build HGTD_TrackingGeometry ..." );
 
  // the enclosed input volume (ID)
  double enclosedInnerSectorHalflength = std::numeric_limits<float>::max();
  double enclosedOuterRadius = 0.;
  double enclosedInnerRadius = 0.;
 
  if (innerVol) {
    ATH_MSG_VERBOSE( "Got Inner Detector Volume: " << innerVol->volumeName() );
    innerVol->screenDump(msg(MSG::VERBOSE));
 
    // retrieve dimensions
    const Trk::CylinderVolumeBounds* innerDetectorBounds
      = dynamic_cast<const Trk::CylinderVolumeBounds*>(&(innerVol->volumeBounds()));
    if (!innerDetectorBounds) std::abort();
 
    enclosedInnerSectorHalflength = innerDetectorBounds->halflengthZ();
    enclosedOuterRadius = innerDetectorBounds->outerRadius();
    enclosedInnerRadius = innerDetectorBounds->innerRadius();
  }
 
  float enclosedOuterSectorHalflength = std::numeric_limits<float>::max();
  // for the HGTD we only need the first envelope definition
  for (const auto & bounds : m_enclosingEnvelopeSvc->getCaloRZBoundary()) {
    if (std::abs(bounds.second) < enclosedOuterSectorHalflength) {
      enclosedOuterSectorHalflength = std::abs(bounds.second);
    }
  }
 
  // in case you have no inner volume you need to find the
  // envelope extensions --> beampipe and HGTD
  if (not innerVol) {
    // from the beampipe envelope you get the inner z extension
    for (const auto & bounds : m_enclosingEnvelopeSvc->getBeamPipeRZBoundary()) {
      if (std::abs(bounds.second) < enclosedInnerSectorHalflength) {
        enclosedInnerSectorHalflength = std::abs(bounds.second);
      }
    }
    // from the calo envelope you get the outer radius
    for (const auto & bounds : m_enclosingEnvelopeSvc->getCaloRZBoundary()) {
      if (std::abs(bounds.second) == enclosedOuterSectorHalflength) {
        if (bounds.first>enclosedOuterRadius)
          enclosedOuterRadius=bounds.first;
      }
    }
  }
 
  ATH_MSG_VERBOSE("Got Dimensions Zmin/Rmin - Zmax/Rmax: "
                  << enclosedInnerSectorHalflength << "/" << enclosedInnerRadius
                  << " - " << enclosedOuterSectorHalflength << "/"
                  << enclosedOuterRadius);
 
  // prepare the layers
  std::vector<Trk::Layer*> negativeLayers;
  std::vector<Trk::Layer*> positiveLayers;
 
  std::unique_ptr<const std::vector<Trk::DiscLayer*> > discLayers = m_layerBuilder->discLayers(ctx, whandle);
 
  float maxZ = -9999.;
  float minZ =  9999.;
  float thickness = -9999;
 
  // loop and fill positive and negative Layers
  if (discLayers && !discLayers->empty()){
    // loop over and push into the return/cache vector
    for (const auto & discLayer : (*discLayers) ){
      // get the center posituion
      float zpos = discLayer->surfaceRepresentation().center().z();
      if (zpos > 0) {
        positiveLayers.push_back(discLayer);
        // only saving layer info for positive side
        // as the detector is simmetric
        maxZ = std::max(maxZ, zpos);
        minZ = std::min(minZ, zpos);
        thickness = std::max(thickness, float(discLayer->thickness()));
      }
      else {
        negativeLayers.push_back(discLayer);
      }
    }
  }
 
  float envelope = thickness*0.5;
  float minZ_HGTD = minZ-envelope;
  float maxZ_HGTD = maxZ+envelope;
  float maxZ_HGTDEnclosure = enclosedOuterSectorHalflength;
 
  // dummy material property
  auto materialProperties = std::make_unique<Trk::Material>();
 
  float zGapPos = 0.5*(minZ_HGTD+enclosedInnerSectorHalflength);
  float gapHalfLengthZ = 0.5*(minZ_HGTD-enclosedInnerSectorHalflength);
 
  // create the gap between the ID and the HGTD endcap volumes
  auto negativeInnerGapTrans = std::make_unique<Amg::Transform3D>(Amg::Translation3D(Amg::Vector3D(0.,0.,-zGapPos)));
  auto negativeInnerGapBounds = std::make_shared<Trk::CylinderVolumeBounds>(enclosedInnerRadius,enclosedOuterRadius,gapHalfLengthZ);
 
  Trk::TrackingVolume * negativeInnerGapVolume =
      new Trk::TrackingVolume(std::move(negativeInnerGapTrans),
                              negativeInnerGapBounds,
                              *materialProperties,
                              nullptr, nullptr,
                              m_layerBuilder->identification()+"::NegativeInnerGap");
 
  auto positiveInnerGapTrans = std::make_unique<Amg::Transform3D>(Amg::Translation3D(Amg::Vector3D(0.,0.,zGapPos)));
  auto positiveInnerGapBounds = std::make_shared<Trk::CylinderVolumeBounds>(enclosedInnerRadius,enclosedOuterRadius,gapHalfLengthZ);
 
  Trk::TrackingVolume * positiveInnerGapVolume =
       new Trk::TrackingVolume(std::move(positiveInnerGapTrans),
                               std::move(positiveInnerGapBounds),
                               *materialProperties,
                               nullptr, nullptr,
                               m_layerBuilder->identification()+"::PositiveInnerGap");
 
  // create dummy inner volume if not built already
  if (not innerVol) {
    auto idBounds = std::make_shared<Trk::CylinderVolumeBounds>(enclosedInnerRadius,
                                                                enclosedInnerSectorHalflength);
    auto idTr = std::make_unique<Amg::Transform3D>(Trk::s_idTransform);
 
    innerVol = new Trk::TrackingVolume(std::move(idTr), std::move(idBounds), *materialProperties,
                                       nullptr, nullptr,
                                       "HGTD::GapVolumes::DummyID");
  }
 
  std::vector<Trk::TrackingVolume*> inBufferVolumes;
  inBufferVolumes.push_back(negativeInnerGapVolume);
  inBufferVolumes.push_back(innerVol);
  inBufferVolumes.push_back(positiveInnerGapVolume);
 
  Trk::TrackingVolume* inDetEnclosed =
    m_trackingVolumeCreator->createContainerTrackingVolume(inBufferVolumes,
                                                           *materialProperties,
                                                           "HGTD::Container::EnclosedInnerDetector");
 
  // create the tracking volumes
  // create the three volumes
  Trk::TrackingVolume* negativeVolume =
    m_trackingVolumeCreator->createTrackingVolume(negativeLayers,
                                                  *materialProperties,
                                                  enclosedInnerRadius, enclosedOuterRadius,
                                                  -maxZ_HGTD, -minZ_HGTD,
                                                  m_layerBuilder->identification()+"::NegativeEndcap",
                                                  (Trk::BinningType)m_layerBinningType);
 
 
  Trk::TrackingVolume* positiveVolume =
    m_trackingVolumeCreator->createTrackingVolume(positiveLayers,
                                                  *materialProperties,
                                                  enclosedInnerRadius, enclosedOuterRadius,
                                                  minZ_HGTD, maxZ_HGTD,
                                                  m_layerBuilder->identification()+"::PositiveEndcap",
                                                  (Trk::BinningType)m_layerBinningType);
 
  // the base volumes have been created
  ATH_MSG_VERBOSE('\t' << '\t'<< "Volumes have been created, now pack them into a triple.");
  negativeVolume->registerColorCode(m_colorCodeConfig);
  inDetEnclosed->registerColorCode(m_colorCodeConfig);
  positiveVolume->registerColorCode(m_colorCodeConfig);
 
  // pack them together
  std::vector<Trk::TrackingVolume*> tripleVolumes;
  tripleVolumes.push_back(negativeVolume);
  tripleVolumes.push_back(inDetEnclosed);
  tripleVolumes.push_back(positiveVolume);
 
  // create the tiple container
  Trk::TrackingVolume* tripleContainer =
    m_trackingVolumeCreator->createContainerTrackingVolume(tripleVolumes,
                                                           *materialProperties,
                                                           "HGTD::Containers::" + m_layerBuilder->identification(),
                                                           m_buildBoundaryLayers,
                                                           m_replaceJointBoundaries);
 
  ATH_MSG_VERBOSE( '\t' << '\t'<< "Created container volume with bounds: " << tripleContainer->volumeBounds() );
 
  // finally create the two endplates: negative
  Trk::TrackingVolume* negativeEnclosure = m_trackingVolumeCreator->createGapTrackingVolume(
    *materialProperties,
    enclosedInnerRadius,
    enclosedOuterRadius,
    -maxZ_HGTDEnclosure,
    -maxZ_HGTD,
    1,
    false,
    "HGTD::Gaps::NegativeEnclosure" + m_layerBuilder->identification());
 
  // finally create the two endplates: positive
  Trk::TrackingVolume* positiveEnclosure = m_trackingVolumeCreator->createGapTrackingVolume(
    *materialProperties,
    enclosedInnerRadius,
    enclosedOuterRadius,
    maxZ_HGTD,
    maxZ_HGTDEnclosure,
    1,
    false,
    "HGTD::Gaps::PositiveEnclosure" + m_layerBuilder->identification());
  // and the final tracking volume
  std::vector<Trk::TrackingVolume*> enclosedVolumes;
  enclosedVolumes.push_back(negativeEnclosure);
  enclosedVolumes.push_back(tripleContainer);
  enclosedVolumes.push_back(positiveEnclosure);
 
   Trk::TrackingVolume* enclosedDetector =
      m_trackingVolumeCreator->createContainerTrackingVolume(enclosedVolumes,
                                                             *materialProperties,
                                                             "HGTD::Detectors::"+m_layerBuilder->identification(),
                                                             m_buildBoundaryLayers,
                                                             m_replaceJointBoundaries);
 
  ATH_MSG_VERBOSE( '\t' << '\t'<< "Created enclosed HGTD volume with bounds: " << enclosedDetector->volumeBounds() );
 
  //  create the TrackingGeometry ------------------------------------------------------
  auto hgtdTrackingGeometry = std::make_unique<Trk::TrackingGeometry>(enclosedDetector);
 
  if (m_indexStaticLayers and hgtdTrackingGeometry)
   hgtdTrackingGeometry->indexStaticLayers( geometrySignature() );
  if (msgLvl(MSG::VERBOSE) && hgtdTrackingGeometry)
    hgtdTrackingGeometry->printVolumeHierarchy(msg(MSG::VERBOSE));
 
  return hgtdTrackingGeometry;
}

Member Data Documentation

m_buildBoundaryLayers

bool HGTD_TrackingGeometryBuilderCond::m_buildBoundaryLayers

private

create boundary layers

Definition at line 66 of file HGTD_TrackingGeometryBuilderCond.h.

m_colorCodeConfig

unsigned int HGTD_TrackingGeometryBuilderCond::m_colorCodeConfig

private

Color code for layers.

Definition at line 72 of file HGTD_TrackingGeometryBuilderCond.h.

m_enclosingEnvelopeSvc

ServiceHandle<IEnvelopeDefSvc> HGTD_TrackingGeometryBuilderCond::m_enclosingEnvelopeSvc

private

Service to handle the envelope definition.

Definition at line 56 of file HGTD_TrackingGeometryBuilderCond.h.

m_indexStaticLayers

bool HGTD_TrackingGeometryBuilderCond::m_indexStaticLayers

private

configurations for the layer builder

forces robust indexing for layers

Definition at line 64 of file HGTD_TrackingGeometryBuilderCond.h.

m_layerBinningType

int HGTD_TrackingGeometryBuilderCond::m_layerBinningType

private

binning type for layers

Definition at line 70 of file HGTD_TrackingGeometryBuilderCond.h.

m_layerBuilder

ToolHandle<Trk::ILayerBuilderCond> HGTD_TrackingGeometryBuilderCond::m_layerBuilder

private

Helper tools for the geometry building.

Definition at line 58 of file HGTD_TrackingGeometryBuilderCond.h.

m_replaceJointBoundaries

bool HGTD_TrackingGeometryBuilderCond::m_replaceJointBoundaries

private

run with replacement of all joint boundaries

Definition at line 68 of file HGTD_TrackingGeometryBuilderCond.h.

m_trackingVolumeCreator

ToolHandle<Trk::ITrackingVolumeCreator> HGTD_TrackingGeometryBuilderCond::m_trackingVolumeCreator

private

Helper Tool to create TrackingVolumes.

Definition at line 60 of file HGTD_TrackingGeometryBuilderCond.h.

---

The documentation for this class was generated from the following files:

• HGTD_TrackingGeometryBuilderCond.h
• HGTD_TrackingGeometryBuilderCond.cxx