Trk::CylinderVolumeCreator Class Reference

The concrete implementation for cylindrical TrackingVolume objects of the ITrackingVolumeCreator interface. More...

#include <CylinderVolumeCreator.h>

Inheritance diagram for Trk::CylinderVolumeCreator:

Collaboration diagram for Trk::CylinderVolumeCreator:

Public Member Functions
	CylinderVolumeCreator (const std::string &, const std::string &, const IInterface *)
	Constructor.
virtual StatusCode	initialize () override
	AlgTool initialize method.
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
	;
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
virtual StatusCode	sysInitialize () override
	Perform system initialization for an algorithm.
virtual StatusCode	sysStart () override
	Handle START transition.
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles.
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T, V, H > &t)
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
bool	msgLvl (const MSG::Level lvl) const
	DeclareInterfaceID (ITrackingVolumeCreator, 1, 0)
	Creates the InterfaceID and interfaceID() method.

Protected Member Functions
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void >	renounce (T &h)
void	extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
	Add StoreName to extra input/output deps as needed.

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
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
	Private method - it estimates the CylinderBounds and Translation of layers, if given, these are checked against the layer positions/dimensions.
StatusCode	interGlueTrackingVolume (TrackingVolume &tVolume, bool rBinned, bool buildBoundaryLayers, bool replaceBoundaryFace=false) const
	Private method - interglue all volumes contained by a TrackingVolume and set the outside glue volumes in the descriptor.
void	addFaceVolumes (TrackingVolume &tvol, Trk::BoundarySurfaceFace bsf, std::vector< Trk::TrackingVolume * > &vols) const
	Private method - helper method not to duplicate code.
void	glueTrackingVolumes (TrackingVolume &volumeOne, BoundarySurfaceFace faceOne, TrackingVolume &volumeTwo, BoundarySurfaceFace faceTwo, bool buildBoundaryLayers, bool replaceBoundaryFace=false) const
	Private method - glue volume to the other – use trackingVolume helper.
CylinderLayer *	createCylinderLayer (double z, double r, double halflength, double thickness, int binsPhi, int binsZ) const
	Private method - helper method to save some code.
DiscLayer *	createDiscLayer (double z, double rMin, double rMax, double thickness, int binsPhi, int binsR) const
	Private method - helper method to save some code.
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
ToolHandle< ILayerArrayCreator >	m_layerArrayCreator {this, "LayerArrayCreator", "Trk::LayerArrayCreator/LayerArrayCreator"}
	< A Tool for coherent LayerArray creation
ToolHandle< ITrackingVolumeArrayCreator >	m_trackingVolumeArrayCreator
	TrackingVolume helper.
ToolHandle< ITrackingVolumeHelper >	m_trackingVolumeHelper
Gaudi::Property< double >	m_passiveLayerThickness
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"}
StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default).
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default).
std::vector< SG::VarHandleKeyArray * >	m_vhka
bool	m_varHandleArraysDeclared

Detailed Description

The concrete implementation for cylindrical TrackingVolume objects of the ITrackingVolumeCreator interface.

Author

Andre.nosp@m.as.S.nosp@m.alzbu.nosp@m.rger.nosp@m.@cern.nosp@m..ch

Definition at line 48 of file CylinderVolumeCreator.h.

Member Typedef Documentation

StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< AlgTool > >::StoreGateSvc_t

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

CylinderVolumeCreator()

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

Constructor.

Definition at line 27 of file CylinderVolumeCreator.cxx.

: AthAlgTool(t,n,p)
{
    declareInterface<ITrackingVolumeCreator>(this);
}

Member Function Documentation

addFaceVolumes()

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

private

Private method - helper method not to duplicate code.

Definition at line 687 of file CylinderVolumeCreator.cxx.

{
 
    ATH_MSG_VERBOSE( "Adding face volumes of face " << glueFace << " for the volume '" << tvol.volumeName() << "'." );
    // retrieve the gluevolume descriptor
    Trk::GlueVolumesDescriptor& gvDescriptor = tvol.glueVolumesDescriptor();
    // if volumes are registered: take them
    if (!gvDescriptor.glueVolumes(glueFace).empty()) {
        // get the navigation level subvolumes
        std::vector<Trk::TrackingVolume*>::const_iterator volIter = gvDescriptor.glueVolumes(glueFace).begin();
        std::vector<Trk::TrackingVolume*>::const_iterator volEnd  = gvDescriptor.glueVolumes(glueFace).end();
        for ( ; volIter != volEnd; ++volIter){
            ATH_MSG_VERBOSE( "     -> adding volumes : " << (*volIter)->volumeName() );
            vols.push_back(*volIter);
        }
        // screen output
        ATH_MSG_VERBOSE( vols.size() << " navigation volumes registered as glue volumes." );
    } else {
        // the volume itself is on navigation level
        ATH_MSG_VERBOSE( "Volume is on navigation level." );
        vols.push_back(&tvol);
    }
}

createContainerTrackingVolume()

Trk::TrackingVolume * Trk::CylinderVolumeCreator::createContainerTrackingVolume ( const std::vector< TrackingVolume * > & volumes, const Material & matprop, const std::string & volumeName = "UndefinedVolume", bool buildBoundaryLayers = false, bool replaceBoundaryFace = false ) const

finaloverridevirtual

;

;

Implements Trk::ITrackingVolumeCreator.

Definition at line 320 of file CylinderVolumeCreator.cxx.

{
  // check if you have more than one volume
  if (volumes.size() <= (unsigned int)1) {
    ATH_MSG_WARNING("None (only one) TrackingVolume given to create container "
                    "volume (min required: 2) - returning 0 ");
    return nullptr;
  }
 
  // screen output
  ATH_MSG_VERBOSE("[start] Creating container volume '"
                  << volumeName << "' with " << volumes.size()
                  << " sub volumes:");
  // volumes need to be sorted in either r or z - both increasing
  // set the iterator to the volumes, the first and the end
  auto firstVolume = volumes.begin();
  auto lastVolume = volumes.end();
 
  for (unsigned int ivol = 0; firstVolume != lastVolume;
       ++firstVolume, ++ivol) {
    ATH_MSG_VERBOSE("   - volume ("
                    << ivol << ") is : " << (*firstVolume)->volumeName());
    ATH_MSG_VERBOSE(
      "     at position : " << Amg::toString((*firstVolume)->center()));
    ATH_MSG_VERBOSE("     with bounds : " << (*firstVolume)->volumeBounds());
  }
 
  // reset the iterator
  firstVolume = volumes.begin();
  --lastVolume; // set to the last volume
 
  if (firstVolume == lastVolume) {
    ATH_MSG_WARNING("Only one TrackingVolume given to create Top level volume "
                    "(min required: 2) - returning 0 ");
    return nullptr;
  }
 
  // get the bounds
  const Trk::CylinderVolumeBounds* firstVolumeBounds =
    dynamic_cast<const Trk::CylinderVolumeBounds*>(
      &((*firstVolume)->volumeBounds()));
  const Trk::CylinderVolumeBounds* lastVolumeBounds =
    dynamic_cast<const Trk::CylinderVolumeBounds*>(
      &((*lastVolume)->volumeBounds()));
  // check the dynamic cast
  if (!firstVolumeBounds || !lastVolumeBounds) {
    ATH_MSG_WARNING("VolumeBounds given are not of type: "
                    "Trk::CylinderVolumeBounds (required) - returning 0 ");
    return nullptr;
  }
 
  // check whether it is a r-binned case or a z-binned case
  bool rCase = fabs(firstVolumeBounds->innerRadius() -
                    lastVolumeBounds->innerRadius()) > 0.1;
  // fill these ones depending on the rCase though assignment - no parsing at
  // that stage
  double zMin = 0.;
  double zMax = 0.;
  double rMin = 0.;
  double rMax = 0.;
  if (rCase) {
    zMin = (*firstVolume)->center().z() - firstVolumeBounds->halflengthZ();
    zMax = (*firstVolume)->center().z() + firstVolumeBounds->halflengthZ();
    rMin = firstVolumeBounds->innerRadius();
    rMax = lastVolumeBounds->outerRadius();
  } else {
    zMin = (*firstVolume)->center().z() - firstVolumeBounds->halflengthZ();
    zMax = (*lastVolume)->center().z() + lastVolumeBounds->halflengthZ();
    rMin = firstVolumeBounds->innerRadius();
    rMax = firstVolumeBounds->outerRadius();
  }
 
  // estimate the z - position
  double zPos = 0.5 * (zMin + zMax);
  // create the HEP transform from the stuff known so far
  std::unique_ptr<Amg::Transform3D> topVolumeTransform =
    fabs(zPos) > 0.1 ? std::make_unique<Amg::Transform3D>(Amg::Translation3D(0., 0., zPos)) : nullptr;
  // create the bounds from the information gathered so far
  auto topVolumeBounds =
    fabs(rMin) > 0.1
      ? std::make_shared<Trk::CylinderVolumeBounds>(rMin, rMax, 0.5 * fabs(zMax - zMin))
      : std::make_shared<Trk::CylinderVolumeBounds>(rMax, 0.5 * fabs(zMax - zMin));
  // create the volume array to fill in
  std::unique_ptr<Trk::BinnedArray<Trk::TrackingVolume>> volumeArray =
    (rCase) ? m_trackingVolumeArrayCreator->cylinderVolumesArrayInR(volumes)
            : m_trackingVolumeArrayCreator->cylinderVolumesArrayInZ(volumes);
  if (!volumeArray) {
    ATH_MSG_WARNING(
      "Creation of TrackingVolume array did not succeed - returning 0 ");
    return nullptr;
  }
 
  // we have the bounds and the volume array, create the volume
  Trk::TrackingVolume* topVolume = new Trk::TrackingVolume(
    std::move(topVolumeTransform),
    std::move(topVolumeBounds),
    matprop,
    nullptr,
    std::move(volumeArray),
    volumeName);
 
  // glueing section
  // --------------------------------------------------------------------------------------
  if (interGlueTrackingVolume(
        *topVolume, rCase, buildBoundaryLayers, replaceBoundaryFace)
        .isFailure()) {
    ATH_MSG_WARNING(
      "Problem with inter-glueing of TrackingVolumes (needed) - returning 0 ");
    delete topVolume;
    return nullptr;
  }
 
  ATH_MSG_VERBOSE(
    "[ end ] return newly created container : " << topVolume->volumeName());
 
  return topVolume;
}

createCylinderLayer()

Trk::CylinderLayer * Trk::CylinderVolumeCreator::createCylinderLayer ( double z, double r, double halflength, double thickness, int binsPhi, int binsZ ) const

private

Private method - helper method to save some code.

Definition at line 785 of file CylinderVolumeCreator.cxx.

{
    ATH_MSG_VERBOSE( "Creating a CylinderLayer at position " << z << " and radius " << r );
    // prepare the material
    Trk::BinnedLayerMaterial cylinderMaterial{};
    // positioning
    std::unique_ptr<Amg::Transform3D> transform =
      (fabs(z) > 0.1) ? std::make_unique<Amg::Transform3D>(Amg::Translation3D(0., 0., z)) : nullptr;
 
    // z-binning
    Trk::BinUtility layerBinUtility(binsZ,z-halflengthZ,z+halflengthZ,Trk::open,Trk::binZ);
    if (binsPhi==1){
        // the BinUtility for the material
        // ---------------------> create the layer material
        cylinderMaterial = Trk::BinnedLayerMaterial(layerBinUtility);
        ATH_MSG_VERBOSE( " -> Preparing the binned material with "
                << binsZ << " bins in Z. ");
 
    } else { // break the phi symmetry
        // update the BinUtility: local position on Cylinder is rPhi, z
        Trk::BinUtility layerBinUtilityRPhiZ(binsPhi,-r*M_PI,+r*M_PI,Trk::closed,Trk::binRPhi);
                               layerBinUtilityRPhiZ += layerBinUtility;
        // ---------------------> create the layer material
        cylinderMaterial = Trk::BinnedLayerMaterial(layerBinUtilityRPhiZ);
 
        ATH_MSG_VERBOSE( " -> Preparing the binned material with "
                << binsPhi << " / " <<  binsZ << " bins in R*phi / Z. ");
    }
    // bounds
    auto cylinderBounds = std::make_shared<Trk::CylinderBounds>(r,halflengthZ);
    // create the cylinder
    Trk::CylinderLayer* cylinderLayer =
        transform
            ? new Trk::CylinderLayer(*transform, cylinderBounds,
                                     cylinderMaterial, thickness, nullptr,
                                     int(Trk::passive))
            : new Trk::CylinderLayer(cylinderBounds, cylinderMaterial,
                                     thickness, nullptr, int(Trk::passive));
    // and return it
    return cylinderLayer;
}

createDiscLayer()

Trk::DiscLayer * Trk::CylinderVolumeCreator::createDiscLayer ( double z, double rMin, double rMax, double thickness, int binsPhi, int binsR ) const

private

Private method - helper method to save some code.

Definition at line 833 of file CylinderVolumeCreator.cxx.

{
 
    ATH_MSG_VERBOSE( "Creating a DiscLayer at position " << z << " and rMin/rMax " << rMin << " / " << rMax);
 
    // positioning
    Amg::Transform3D transform =
      fabs(z) > 0.1 ? Amg::Transform3D((Amg::Translation3D(0.,0.,z))) : Amg::Transform3D::Identity();
 
    // R is the primary binning for the material
    Trk::BinUtility layerBinUtility(binsR, rMin, rMax, Trk::open, Trk::binR);
    if (binsPhi==1) {
        ATH_MSG_VERBOSE( " -> Preparing the binned material with "
                << binsR << " bins in R. ");
    } else {
        // also binning in phi chosen
        layerBinUtility += Trk::BinUtility(binsPhi, -M_PI, M_PI, Trk::closed, Trk::binPhi);
        ATH_MSG_VERBOSE( " -> Preparing the binned material with "
            << binsPhi << " / " <<  binsR << " bins in phi / R. ");
    }
    // ---------------------> create the layer material
    auto discMaterial = Trk::BinnedLayerMaterial(layerBinUtility);
    // bounds
    auto discBounds = std::make_shared<Trk::DiscBounds>(rMin,rMax);
    // create the disc
    Trk::DiscLayer* discLayer =  new Trk::DiscLayer(transform, discBounds, discMaterial,
                                                    thickness, nullptr, int(Trk::passive));
 
    // and return it
    return discLayer;
}

createGapTrackingVolume() [1/2]

Trk::TrackingVolume * Trk::CylinderVolumeCreator::createGapTrackingVolume ( Trk::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

finaloverridevirtual

ITrackingVolumeCreator::createGaoTrackingVolume(Material&,,std::vector<double>&,int,bool,const std::string&) const;

Implements Trk::ITrackingVolumeCreator.

Definition at line 263 of file CylinderVolumeCreator.cxx.

{
 
  // screen output
  ATH_MSG_VERBOSE("Create cylindrical gap TrackingVolume '"
                  << volumeName << "' with (rMin/rMax/zMin/Max) = ");
  ATH_MSG_VERBOSE('\t' << rMin << " / " << rMax << " / " << zMin << " / "
                       << zMax);
 
  // create the layers
  std::vector<Trk::Layer*> layers;
  layers.reserve(layerPositions.size());
 
  std::vector<double>::const_iterator layerPropIter = layerPositions.begin();
  std::vector<double>::const_iterator layerPropEnd = layerPositions.end();
  for (; layerPropIter != layerPropEnd; ++layerPropIter) {
    // create cylinder layers
    if (cylinder) {
      // take envelopes into account
      double zMinLayer = zMin;
      double zMaxLayer = zMax;
      // create the layer
      layers.push_back(createCylinderLayer(0.5 * (zMinLayer + zMaxLayer),
                                           (*layerPropIter),
                                           fabs(0.5 * (zMaxLayer - zMinLayer)),
                                           m_passiveLayerThickness,
                                           m_passiveLayerPhiBins,
                                           m_passiveLayerRzBins));
 
    } else {
      // take the envelopes into account
      double rMinLayer = rMin;
      double rMaxLayer = rMax;
      // create the layer
      layers.push_back(createDiscLayer((*layerPropIter),
                                       rMinLayer,
                                       rMaxLayer,
                                       m_passiveLayerThickness,
                                       m_passiveLayerPhiBins,
                                       m_passiveLayerRzBins));
    }
  }
  // now call the createTrackingVolume() method
  return createTrackingVolume(
    layers, matprop, rMin, rMax, zMin, zMax, volumeName, btype);
}

createGapTrackingVolume() [2/2]

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

finaloverridevirtual

ITrackingVolumeCreator::createGapTrackingVolume(Material&,,double,double,double,double,int,bool,const std::string&) const;

Implements Trk::ITrackingVolumeCreator.

Definition at line 220 of file CylinderVolumeCreator.cxx.

{
 
    // screen output
    ATH_MSG_VERBOSE( "Create cylindrical gap TrackingVolume '" << volumeName << "' with (rMin/rMax/zMin/Max) = ");
    ATH_MSG_VERBOSE( '\t' << rMin << " / " << rMax << " / " << zMin << " / " << zMax );
 
    // assing min/max
    double min = cylinder ? rMin : zMin;
    double max = cylinder ? rMax : zMax;
 
    // create the layer r/z positions
    std::vector<double> layerPositions;
    layerPositions.reserve(materialLayers);
    if (materialLayers > 1){
        //double step = cylinder ? (max-min)/(materialLayers-1) : (max-min)/(materialLayers-1);
        const double step=(max-min)/(materialLayers-1);
        for (unsigned int il = 0; il < materialLayers; ++il)
            layerPositions.push_back(min+il*step);
    } else
        layerPositions.push_back(0.5*(min+max));
 
    // now call the main method
    return createGapTrackingVolume(matprop,
                                   rMin,
                                   rMax,
                                   zMin,
                                   zMax,
                                   layerPositions,
                                   cylinder,
                                   volumeName,
                                   (layerPositions.size() == 1 ? Trk::arbitrary : Trk::biequidistant));
 
}

createTrackingVolume() [1/2]

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

finaloverridevirtual

;

;

Implements Trk::ITrackingVolumeCreator.

Definition at line 172 of file CylinderVolumeCreator.cxx.

{
  // that's what is needed
  Trk::CylinderVolumeBounds* cBounds = nullptr;
 
  // screen output
  ATH_MSG_VERBOSE("Create cylindrical TrackingVolume '" << volumeName << "'.");
  ATH_MSG_VERBOSE("    -> with given dimensions of (rMin/rMax/zMin/Max) = "
                  << rMin << " / " << rMax << " / " << zMin << " / " << zMax);
 
  // check for consistency
  if (zMin > zMax || rMin > rMax) {
    ATH_MSG_WARNING("Inconsistent dimensions given :"
                    << ((zMin > zMax) ? " zMin > zMax (" : " rMin > rMax (")
                    << ((zMin > zMax) ? zMin : rMin) << " > "
                    << ((zMin > zMax) ? zMax : rMax) << " ) - return 0");
    return nullptr;
  }
 
  // create a Amg::Transform3D and VolumeBounds out of the zMin/zMax
  double halflengthZ = 0.5 * (zMax - zMin);
  double zPosition = 0.5 * (zMin + zMax);
  zPosition = fabs(zPosition) < 0.1 ? 0. : zPosition;
 
  // now create the cylinder volume bounds
  cBounds = rMin > 0.1 ? new Trk::CylinderVolumeBounds(rMin, rMax, halflengthZ)
                       : new Trk::CylinderVolumeBounds(rMax, halflengthZ);
  // transform
  Amg::Transform3D* transform =
    (zPosition != 0) ? new Amg::Transform3D : nullptr;
  if (transform)
    (*transform) = Amg::Translation3D(0., 0., zPosition);
 
  // call to the Bounds/Amg::Translation3D method
  return createTrackingVolume(
    layers, matprop, cBounds, transform, volumeName, btype);
}

createTrackingVolume() [2/2]

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

finaloverridevirtual

;

;

Implements Trk::ITrackingVolumeCreator.

Definition at line 70 of file CylinderVolumeCreator.cxx.

{
 
    // the final one to build / sensitive Volume / Bounds
    Trk::TrackingVolume* tVolume = nullptr;
 
    // cases are:
    // (1) volBounds && transform   : use both information
    // (2) volBounds && !transform  : centered around 0, but with given bounds
    // (3) !volBounds && transform  : estimate size from layers, use transform
    // (4) !volBounds && !transform : estimate size & translation from layers
    Trk::CylinderVolumeBounds* cylinderBounds = nullptr;
    // this is the implementation of CylinderVolumeCreator
    if (volBounds) {
        cylinderBounds = dynamic_cast<Trk::CylinderVolumeBounds*>(volBounds);
        if (!cylinderBounds){
            ATH_MSG_WARNING( "[!] Problem: given bounds were not cylindrical - return 0" );
            return tVolume;
        }
    }
    std::vector<Trk::CylinderLayer*> cylLayers;
    cylLayers.reserve(layers.size());
    std::vector<Trk::DiscLayer*> discLayers;
    discLayers.reserve(layers.size());
 
    // the raw data
    double rMinRaw{0.};
    double rMaxRaw{0.};
    double zMinRaw{0.};
    double zMaxRaw{0.};
 
    // check the dimension and fill raw data
    if (estimateAndCheckDimension(layers,
                                  cylinderBounds,
                                  transform,
                                  cylLayers,
                                  discLayers,
                                  rMinRaw,rMaxRaw,
                                  zMinRaw,zMaxRaw,
                                  btype).isFailure()) {
        ATH_MSG_WARNING( "[!] Problem with given dimensions - return 0 and delete provided objects" );
        delete volBounds; delete transform;
        delete cylinderBounds;
        return tVolume;
    }
 
    // get the zMin/Max
    double zMin = ( transform ? transform->translation().z() : 0. ) +
                  ( cylinderBounds ? -cylinderBounds->halflengthZ() : 0. );
    double zMax = ( transform ? transform->translation().z() : 0. ) +
                  ( cylinderBounds ?  cylinderBounds->halflengthZ() : 0. );
 
    double rMin = 0.;
    double rMax = 0.;
 
    // overrule the zMin/zMax for biequidistant binning
    if (btype == Trk::biequidistant) {
        // set rMin/rMax and zMin/zMax
        zMin = zMinRaw;
        zMax = zMaxRaw;
        rMin = rMinRaw;
        rMax = rMaxRaw;
    } else {
        if (!cylinderBounds) {
          ATH_MSG_WARNING( "[!] No cylindrical bounds given - return 0" );
          return tVolume;
        }
        rMin = cylinderBounds->innerRadius();
        rMax = cylinderBounds->outerRadius();
    }
 
    ATH_MSG_VERBOSE("Filling the layers into an appropriate layer array");
    // create the Layer Array
    std::unique_ptr<Trk::BinnedArray1D<Trk::Layer>> layerArray =
        !cylLayers.empty() ? m_layerArrayCreator->cylinderLayerArray(
                                 cylLayers, rMin, rMax, btype)
                           : m_layerArrayCreator->discLayerArray(
                                 discLayers, zMin, zMax, btype);
 
    // finally create the TrackingVolume
    tVolume = new Trk::TrackingVolume(std::unique_ptr<Amg::Transform3D>(transform),
                                      std::shared_ptr<Trk::CylinderVolumeBounds>(cylinderBounds),
                                      matprop,
                                      std::move(layerArray),
                                      nullptr,
                                      volumeName);
    // screen output
    ATH_MSG_VERBOSE( "Created cylindrical volume at z-position :" <<  tVolume->center().z() );
    ATH_MSG_VERBOSE( "   created bounds : " << tVolume->volumeBounds() );
 
    // return the constructed TrackingVolume
    return tVolume;
}

declareGaudiProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T, V, H > & hndl, const SG::VarHandleKeyType &  )

inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKey>

Definition at line 156 of file AthCommonDataStore.h.

  {
    return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                       hndl.value(), 
                                                       hndl.documentation());
 
  }

DeclareInterfaceID()

Trk::ITrackingVolumeCreator::DeclareInterfaceID ( ITrackingVolumeCreator , 1 , 0  )

inherited

Creates the InterfaceID and interfaceID() method.

declareProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( Gaudi::Property< T, V, H > & t )

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

                                                                     {
    typedef typename SG::HandleClassifier<T>::type htype;
    return AthCommonDataStore<PBASE>::declareGaudiProperty(t, htype());
  }

detStore()

const ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< AlgTool > >::detStore ( ) const

inlineinherited

The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 95 of file AthCommonDataStore.h.

{ return m_detStore; }

estimateAndCheckDimension()

StatusCode Trk::CylinderVolumeCreator::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, Trk::BinningType bType = arbitrary ) const

private

Private method - it estimates the CylinderBounds and Translation of layers, if given, these are checked against the layer positions/dimensions.

private helper method to estimate and check the dimensions of a tracking volume

Definition at line 445 of file CylinderVolumeCreator.cxx.

{
    // check and bail out if no layers are given
    if (layers.empty()) {
        ATH_MSG_VERBOSE( "No layers given, you shouldn't use : "<< type() );
        return StatusCode::FAILURE;
    }
 
    // some verbose output
    ATH_MSG_VERBOSE( "Parsing the " << layers.size() << " layers to gather overall dimensions" );
    if (cylinderVolumeBounds) ATH_MSG_VERBOSE( "Cylinder volume bounds are given." );
 
    // prepare for parsing the layers
    double layerRmin = 10e10;
    double layerRmax = 0.;
    double layerZmin = 10e10;
    double layerZmax = -10e10;
    bool   radial    = false;
 
    rMinClean = 10e10;
    rMaxClean = 0.;
    zMinClean = 10e10;
    zMaxClean = -10e10;
 
    // find out what is there
    for (auto *const layerIter : layers) {
        //class is not thread safe due to this
        // initialize
        double currentRmin = 0.;
        double currentRmax = 0.;
        double currentZmin = 0.;
        double currentZmax = 0.;
        // dynamic cast the bounds either to CylinderBounds or DiscBounds
        const Trk::CylinderBounds* cylBounds =
                dynamic_cast<const Trk::CylinderBounds*>(&(layerIter->surfaceRepresentation()).bounds());
        // cylinder bounds
        if (cylBounds) {
            radial = true;
            // fill it into the cylinderLayer vector
            cylinderLayers.push_back(dynamic_cast<Trk::CylinderLayer*>(layerIter));
            // get the raw data
            double currentR   = cylBounds->r();
            double centerZ     = (layerIter->surfaceRepresentation()).center().z();
            // check for min/max in the cylinder bounds case
            if (bType == Trk::biequidistant){
              currentRmin = currentR; currentRmax = currentR;
            } else {
              currentRmin = currentR-(0.5*(layerIter)->thickness());
              currentRmax = currentR+(0.5*(layerIter)->thickness());
            }
            currentZmin = centerZ - cylBounds->halflengthZ();
            currentZmax = centerZ + cylBounds->halflengthZ();
        }
        // dynamic cast to the DiscBounds
        const Trk::DiscBounds* discBounds =
                dynamic_cast<const Trk::DiscBounds*>(&(layerIter->surfaceRepresentation()).bounds());
        if (discBounds) {
            // fill it into the discLayer vector
            discLayers.push_back(dynamic_cast<Trk::DiscLayer*>(layerIter));
            // check for min/max in the cylinder bounds case
            double centerZ     = (layerIter->surfaceRepresentation()).center().z();
            currentRmin = discBounds->rMin();
            currentRmax = discBounds->rMax();
            if (bType == Trk::biequidistant){
              currentZmin = centerZ; currentZmax = centerZ;
            } else {
              currentZmin = centerZ - (0.5*(layerIter)->thickness());
              currentZmax = centerZ + (0.5*(layerIter)->thickness());
            }
        }
        // the raw data
        rMinClean = std::min(rMinClean, currentRmin);
        rMaxClean = std::max(rMaxClean, currentRmax);
        zMinClean = std::min(zMinClean, currentZmin);
        zMaxClean = std::max(zMaxClean, currentZmax);
        // assign if they overrule the minima/maxima (with layers thicknesses)
 
        layerRmin = std::min(layerRmin,currentRmin);
        layerRmax = std::max(layerRmax, currentRmax);
        layerZmin = std::min(layerZmin,currentZmin);
        layerZmax = std::max(layerZmax, currentZmax);
    }
 
    // special for biequidistant binning - navigation layers are added before / after
    if (bType == Trk::biequidistant){
        if (radial){
            double rStepHalf = 0.5*(layerRmax-layerRmin)/(layers.size()-1);
            layerRmin -= rStepHalf;
            layerRmax += rStepHalf;
        } else {
            double zStepHalf = 0.5*(layerZmax-layerZmin)/(layers.size()-1);
            layerZmin -= zStepHalf;
            layerZmax += zStepHalf;
        }
    }
 
    ATH_MSG_VERBOSE( "Estimate/check CylinderVolumeBounds from/w.r.t. enclosed layers + envelope covers" );
    // the z from the layers w and w/o envelopes
    double zEstFromLayerEnv =  0.5*((layerZmax)+(layerZmin));
    double halflengthFromLayer = 0.5*fabs((layerZmax)-(layerZmin));
 
    bool concentric = (zEstFromLayerEnv*zEstFromLayerEnv < 0.001);
 
    // no CylinderBounds and Translation given - make it
    if (!cylinderVolumeBounds && !transform) {
        // create the CylinderBounds from parsed layer inputs
        cylinderVolumeBounds = new Trk::CylinderVolumeBounds(layerRmin,layerRmax,halflengthFromLayer);
        // and the transform
        transform = concentric ? new Amg::Transform3D : nullptr;
        if (transform)
           (*transform) = Amg::Translation3D(0.,0.,zEstFromLayerEnv);
    } else if (cylinderVolumeBounds && !transform &&!concentric){
        transform = new Amg::Transform3D;
        (*transform) = Amg::Translation3D(0.,0.,zEstFromLayerEnv);
    }
    else if (transform && !cylinderVolumeBounds) {
        // create the CylinderBounds from parsed layer inputs
        double halflengthFromLayer = 0.5*fabs((layerZmax)-(layerZmin));
        cylinderVolumeBounds = new Trk::CylinderVolumeBounds(layerRmin,
                                                             layerRmax,
                                                             halflengthFromLayer);
    }
 
    ATH_MSG_VERBOSE( "    -> dimensions from layers   (rMin/rMax/zMin/zMax) = "
            << layerRmin << " / " << layerRmax << " / " << layerZmin << " / " << layerZmax );
    double zFromTransform = transform ? transform->translation().z() : 0.;
    ATH_MSG_VERBOSE( "    -> while created bounds are (rMin/rMax/zMin/zMax) = "
            << cylinderVolumeBounds->innerRadius() << " / " << cylinderVolumeBounds->outerRadius() << " / "
            << zFromTransform-cylinderVolumeBounds->halflengthZ()  << " / " << zFromTransform+cylinderVolumeBounds->halflengthZ() );
 
 
    // both is NOW given --- check it -----------------------------
    if (cylinderVolumeBounds) {
        // only check
        if (zFromTransform-cylinderVolumeBounds->halflengthZ() <= layerZmin &&
            zFromTransform+cylinderVolumeBounds->halflengthZ() >= layerZmax &&
            cylinderVolumeBounds->innerRadius() <= layerRmin &&
            cylinderVolumeBounds->outerRadius() >= layerRmax)
            return StatusCode::SUCCESS;
        else {
            ATH_MSG_WARNING( "Provided layers are not contained by volume ! Bailing out. " );
            return StatusCode::FAILURE;
        }
        ATH_MSG_VERBOSE( "Created/Checked " << *cylinderVolumeBounds );
    }
 
 
    return StatusCode::SUCCESS;
}

evtStore()

ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< AlgTool > >::evtStore ( )

inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 85 of file AthCommonDataStore.h.

{ return m_evtStore; }

extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::extraDeps_update_handler ( Gaudi::Details::PropertyBase & ExtraDeps )

protectedinherited

Add StoreName to extra input/output deps as needed.

use the logic of the VarHandleKey to parse the DataObjID keys supplied via the ExtraInputs and ExtraOuputs Properties to add the StoreName if it's not explicitly given

glueTrackingVolumes()

void Trk::CylinderVolumeCreator::glueTrackingVolumes ( Trk::TrackingVolume & tvolOne, Trk::BoundarySurfaceFace faceOne, Trk::TrackingVolume & tvolTwo, Trk::BoundarySurfaceFace faceTwo, bool buildBoundaryLayers, bool replaceBoundaryFace = false ) const

private

Private method - glue volume to the other – use trackingVolume helper.

private helper method to fill the glue volumes (or the volume itself in)

Definition at line 715 of file CylinderVolumeCreator.cxx.

{
 
    // get the two gluevolume descriptors
    Trk::GlueVolumesDescriptor& gvDescriptorOne = tvolOne.glueVolumesDescriptor();
    Trk::GlueVolumesDescriptor& gvDescriptorTwo = tvolTwo.glueVolumesDescriptor();
 
    ATH_MSG_VERBOSE( "Glue method called with " << (replaceBoundaryFace ? "joint boundaries." : "individual boundaries." ) );
 
    size_t volOneGlueVols = gvDescriptorOne.glueVolumes(faceOne).size();
    ATH_MSG_VERBOSE( "GlueVolumeDescriptor of volume '" << tvolOne.volumeName() <<"' has "
            << volOneGlueVols << " @ " << faceOne );
    size_t volTwoGlueVols = gvDescriptorTwo.glueVolumes(faceTwo).size();
    ATH_MSG_VERBOSE( "GlueVolumeDescriptor of volume '" << tvolTwo.volumeName() <<"' has "
            << volTwoGlueVols << " @ " << faceTwo );
 
    // they could still be a container though
    TrackingVolume* glueVolOne = volOneGlueVols ?
            gvDescriptorOne.glueVolumes(faceOne)[0] : &tvolOne;
 
    TrackingVolume* glueVolTwo = volTwoGlueVols ?
            gvDescriptorTwo.glueVolumes(faceTwo)[0] : &tvolTwo;
 
    // check the cases
    // (i) easy volume to volume
    if ( volOneGlueVols <= 1 && volTwoGlueVols <= 1) {
        // now glue it
        ATH_MSG_VERBOSE( "      glue : one[ "<< glueVolOne->volumeName() << " @ " << faceOne
                << " ]-to-one[ "<< glueVolTwo->volumeName() << " @ " << faceTwo << " ]" );
        m_trackingVolumeHelper->glueTrackingVolumes(*glueVolOne,
                                                    faceOne,
                                                    *glueVolTwo,
                                                    faceTwo,
                                                    createBoundaryLayers);
    } else if (volOneGlueVols <= 1) { // (ii) one -> many
        ATH_MSG_VERBOSE( "      glue : one[ "<< glueVolOne->volumeName() << " @ " << faceOne
                << " ]-to-many[ "<< tvolTwo.volumeName() << " @ " << faceTwo << " ]" );
        m_trackingVolumeHelper->glueTrackingVolumes(*glueVolOne,
                                                    faceOne,
                                                    gvDescriptorTwo.glueVolumes(faceTwo),
                                                    faceTwo,
                                                    createBoundaryLayers,
                                                    replaceBoundaryFace);
    } else if (volTwoGlueVols <= 1 ) { // (iii) many -> two
        ATH_MSG_VERBOSE( "      glue : many[ "<< tvolOne.volumeName() << " @ " << faceOne
                << " ]-to-one[ "<< glueVolTwo->volumeName() << " @ " << faceTwo << " ]" );
        m_trackingVolumeHelper->glueTrackingVolumes(*glueVolTwo,
                                                    faceTwo,
                                                    gvDescriptorOne.glueVolumes(faceOne),
                                                    faceOne,
                                                    createBoundaryLayers,
                                                    replaceBoundaryFace);
    } else {
        // (iv) glue array to array
        ATH_MSG_VERBOSE( "      glue : many[ "<< tvolOne.volumeName() << " @ " << faceOne
                << " ]-to-many[ "<< tvolTwo.volumeName() << " @ " << faceTwo << " ]" );
        m_trackingVolumeHelper->glueTrackingVolumes(gvDescriptorOne.glueVolumes(faceOne),
                                                    faceOne,
                                                    gvDescriptorTwo.glueVolumes(faceTwo),
                                                    faceTwo,
                                                    createBoundaryLayers,
                                                    replaceBoundaryFace);
    } // end of case (iv)
}

initialize()

StatusCode Trk::CylinderVolumeCreator::initialize ( )

overridevirtual

AlgTool initialize method.

Definition at line 35 of file CylinderVolumeCreator.cxx.

{
 
    // Retrieve the layer array creator  ----------------------------------------------------
    if (m_layerArrayCreator.retrieve().isFailure())
    {
        ATH_MSG_FATAL( "Failed to retrieve tool " << m_layerArrayCreator );
        return StatusCode::FAILURE;
    } else
        ATH_MSG_DEBUG( "Retrieved tool " << m_layerArrayCreator );
 
 
    // Retrieve the volume array creator  ----------------------------------------------------
    if (m_trackingVolumeArrayCreator.retrieve().isFailure())
    {
        ATH_MSG_FATAL( "Failed to retrieve tool " << m_trackingVolumeArrayCreator );
        return StatusCode::FAILURE;
    } else
        ATH_MSG_DEBUG( "Retrieved tool " << m_trackingVolumeArrayCreator );
 
 
    // Retrieve the volume array creator  ----------------------------------------------------
    if (m_trackingVolumeHelper.retrieve().isFailure())
    {
        ATH_MSG_FATAL( "Failed to retrieve tool " << m_trackingVolumeHelper );
        return StatusCode::FAILURE;
    } else
        ATH_MSG_DEBUG( "Retrieved tool " << m_trackingVolumeHelper );
 
    ATH_MSG_DEBUG( "initialize() successful" );
 
    return StatusCode::SUCCESS;
}

inputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< AlgTool > >::inputHandles ( ) const

overridevirtualinherited

Return this algorithm's input handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

interGlueTrackingVolume()

StatusCode Trk::CylinderVolumeCreator::interGlueTrackingVolume ( Trk::TrackingVolume & tVolume, bool rBinned, bool buildBoundaryLayers, bool replaceBoundaryFace = false ) const

private

Private method - interglue all volumes contained by a TrackingVolume and set the outside glue volumes in the descriptor.

Definition at line 607 of file CylinderVolumeCreator.cxx.

{
 
    ATH_MSG_VERBOSE( "Glue contained TrackingVolumes of container '" << tVolume.volumeName() << "'." );
 
    // get the glueVolumes descriptor of the top volume to register the outside volumes
    Trk::GlueVolumesDescriptor& glueDescr  = tVolume.glueVolumesDescriptor();
 
    // so far we know that we can do that (private method)
    std::span<Trk::TrackingVolume * const> volumes = tVolume.confinedVolumes()->arrayObjects();
 
    // the needed iterators
    auto tVolIter = volumes.begin();
    auto tVolFirst = volumes.begin();
    auto tVolLast = volumes.end(); --tVolLast;
    auto tVolEnd  = volumes.end();
 
    // the glue volumes for the description
    std::vector<Trk::TrackingVolume*> glueVolumesInnerTube;
    std::vector<Trk::TrackingVolume*> glueVolumesOuterTube;
    std::vector<Trk::TrackingVolume*> glueVolumesNegativeFace;
    std::vector<Trk::TrackingVolume*> glueVolumesPositiveFace;
 
    // volumes of increasing r
    if (rBinned) {
        // loop over the volumes -------------------------------
        for ( ; tVolIter != tVolEnd; ) {
            // screen output
            ATH_MSG_VERBOSE("r-binning: Processing volume '" << (*tVolIter)->volumeName() << "'.");
            // for the first one
            if (tVolIter == tVolFirst)
                addFaceVolumes((**tVolIter),Trk::tubeInnerCover,glueVolumesInnerTube);
            // add this or the subvolumes to the negativeFace and positiveFace
            addFaceVolumes((**tVolIter),Trk::negativeFaceXY,glueVolumesNegativeFace);
            addFaceVolumes((**tVolIter),Trk::positiveFaceXY,glueVolumesPositiveFace);
            if (tVolIter == tVolLast) {
                addFaceVolumes((**tVolIter),Trk::tubeOuterCover,glueVolumesOuterTube);
                ++tVolIter;
            } else {
                Trk::TrackingVolume* tVol1 = (*tVolIter);
                Trk::TrackingVolume* tVol2 = (*(++tVolIter));
                glueTrackingVolumes(*tVol1,Trk::tubeOuterCover, *tVol2, Trk::tubeInnerCover, createBoundaryLayers, replaceBoundaryFace);
            }
        }
    } else {
        // volumes in increasing z
        // loop over the volumes
        for ( ; tVolIter != tVolEnd; ) {
            // screen output
            ATH_MSG_VERBOSE("z-binning: Processing volume '" << (*tVolIter)->volumeName() << "'.");
            if (tVolIter == tVolFirst)
                addFaceVolumes((**tVolIter),Trk::negativeFaceXY,glueVolumesNegativeFace);
            addFaceVolumes((**tVolIter),Trk::tubeInnerCover,glueVolumesInnerTube);
            addFaceVolumes((**tVolIter),Trk::tubeOuterCover,glueVolumesOuterTube);
            if (tVolIter == tVolLast) {
                addFaceVolumes((**tVolIter),Trk::positiveFaceXY,glueVolumesPositiveFace);
                ++tVolIter;
            } else {
                Trk::TrackingVolume* tVol1 = (*tVolIter);
                Trk::TrackingVolume* tVol2 = (*(++tVolIter));
                glueTrackingVolumes(*tVol1,Trk::positiveFaceXY,*tVol2,Trk::negativeFaceXY, createBoundaryLayers, replaceBoundaryFace);
            }
        }
    }
 
    // register it with the glueVolumeDescriptor
    glueDescr.registerGlueVolumes(Trk::negativeFaceXY,glueVolumesNegativeFace);
    glueDescr.registerGlueVolumes(Trk::positiveFaceXY,glueVolumesPositiveFace);
    glueDescr.registerGlueVolumes(Trk::tubeInnerCover,glueVolumesInnerTube);
    glueDescr.registerGlueVolumes(Trk::tubeOuterCover,glueVolumesOuterTube);
 
    // return success
    return StatusCode::SUCCESS;
}

msg()

MsgStream & AthCommonMsg< AlgTool >::msg ( ) const

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msgLvl()

bool AthCommonMsg< AlgTool >::msgLvl ( const MSG::Level lvl ) const

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                               {
    return this->msgLevel(lvl);
  }

outputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< AlgTool > >::outputHandles ( ) const

overridevirtualinherited

Return this algorithm's output handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

renounce()

std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > AthCommonDataStore< AthCommonMsg< AlgTool > >::renounce ( T & h )

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

  {
    h.renounce();
    PBASE::renounce (h);
  }

renounceArray()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::renounceArray ( SG::VarHandleKeyArray & handlesArray )

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                          {
    handlesArray.renounce();
  }

sysInitialize()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysInitialize ( )

overridevirtualinherited

Perform system initialization for an algorithm.

We override this to declare all the elements of handle key arrays at the end of initialization. See comments on updateVHKA.

Reimplemented in asg::AsgMetadataTool, AthCheckedComponent< AthAlgTool >, and AthCheckedComponent<::AthAlgTool >.

sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysStart ( )

overridevirtualinherited

Handle START transition.

We override this in order to make sure that conditions handle keys can cache a pointer to the conditions container.

updateVHKA()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::updateVHKA ( Gaudi::Details::PropertyBase & )

inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

                                               {
    // debug() << "updateVHKA for property " << p.name() << " " << p.toString() 
    //         << "  size: " << m_vhka.size() << endmsg;
    for (auto &a : m_vhka) {
      std::vector<SG::VarHandleKey*> keys = a->keys();
      for (auto k : keys) {
        k->setOwner(this);
      }
    }
  }

Member Data Documentation

m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default).

Definition at line 393 of file AthCommonDataStore.h.

m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default).

Definition at line 390 of file AthCommonDataStore.h.

m_layerArrayCreator

ToolHandle<ILayerArrayCreator> Trk::CylinderVolumeCreator::m_layerArrayCreator {this, "LayerArrayCreator", "Trk::LayerArrayCreator/LayerArrayCreator"}

private

< A Tool for coherent LayerArray creation

Helper Tool to create TrackingVolume Arrays

Definition at line 185 of file CylinderVolumeCreator.h.

{this, "LayerArrayCreator", "Trk::LayerArrayCreator/LayerArrayCreator"};

m_passiveLayerPhiBins

Gaudi::Property<int> Trk::CylinderVolumeCreator::m_passiveLayerPhiBins {this, "PassiveLayerBinsPhi", 1, "bins in phi for the passive layer"}

private

Definition at line 199 of file CylinderVolumeCreator.h.

{this, "PassiveLayerBinsPhi", 1, "bins in phi for the passive layer"};

m_passiveLayerRzBins

Gaudi::Property<int> Trk::CylinderVolumeCreator::m_passiveLayerRzBins {this, "PassiveLayerBinsRZ", 100, "bins in r/z for the passive layer"}

private

Definition at line 201 of file CylinderVolumeCreator.h.

{this, "PassiveLayerBinsRZ", 100, "bins in r/z for the passive layer"};

m_passiveLayerThickness

Gaudi::Property<double> Trk::CylinderVolumeCreator::m_passiveLayerThickness

private

Initial value:

{this, "PassiveLayerThickness", 1*Gaudi::Units::mm,
     "thickness of passive layers"}

Definition at line 196 of file CylinderVolumeCreator.h.

    {this, "PassiveLayerThickness", 1*Gaudi::Units::mm,
     "thickness of passive layers"};

m_trackingVolumeArrayCreator

ToolHandle<ITrackingVolumeArrayCreator> Trk::CylinderVolumeCreator::m_trackingVolumeArrayCreator

private

Initial value:

{this, "TrackingVolumeArrayCreator",
     "Trk::TrackingVolumeArrayCreator/TrackingVolumeArrayCreator"}

TrackingVolume helper.

Definition at line 188 of file CylinderVolumeCreator.h.

    {this, "TrackingVolumeArrayCreator",
     "Trk::TrackingVolumeArrayCreator/TrackingVolumeArrayCreator"};

m_trackingVolumeHelper

ToolHandle<ITrackingVolumeHelper> Trk::CylinderVolumeCreator::m_trackingVolumeHelper

private

Initial value:

{this, "TrackingVolumeHelper",
     "Trk::TrackingVolumeHelper/TrackingVolumeHelper"}

Definition at line 192 of file CylinderVolumeCreator.h.

    {this, "TrackingVolumeHelper",
     "Trk::TrackingVolumeHelper/TrackingVolumeHelper"};

m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< AlgTool > >::m_vhka

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

---

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

• CylinderVolumeCreator.h
• CylinderVolumeCreator.cxx