Class to faciliate easy access to sensor information of the VXD like coordinate transformations or pitch size. More...

#include <GeoCache.h>

Public Member Functions
	~GeoCache ()
	destructor to clean up structures

void	clear ()
	Clean up internal structures.

void	findVolumes (G4VPhysicalVolume *envelope)
	Search a given Geometry for Sensors.

void	addSensor (SensorInfoBase *sensorinfo)
	Add a SensorInfo instance to the list of known sensors This method will manually add a SensorInfo instance to the list of known sensors.

const std::set< Belle2::VxdID >	getLayers (SensorInfoBase::SensorType sensortype=SensorInfoBase::VXD)
	Return a set of all known Layers.

const std::set< Belle2::VxdID > &	getLadders (Belle2::VxdID layer) const
	Return a set of all ladder IDs belonging to a given layer.

const std::set< Belle2::VxdID > &	getSensors (Belle2::VxdID ladder) const
	Return a set of all sensor IDs belonging to a given ladder.

bool	validSensorID (Belle2::VxdID id) const
	Check that id is a valid sensor number.

const std::vector< VxdID >	getListOfSensors () const
	Get list of all sensors.

const SensorInfoBase &	getSensorInfo (Belle2::VxdID id) const
	Return a referecne to the SensorInfo of a given SensorID.

const std::map< VxdID, TGeoHMatrix > &	getHalfShellPlacements () const
	Retrieve stored half-shell placements into world volume.

const std::vector< std::pair< VxdID, TGeoHMatrix > > &	getLadderPlacements (VxdID halfShell) const
	Retrieve stored ladder placements into half-shell.

const std::vector< std::pair< VxdID, TGeoHMatrix > > &	getSensorPlacements (VxdID ladder) const
	Retrieve stored sensor placements into ladders.

void	addHalfShellPlacement (VxdID halfShell, const G4Transform3D &placement)
	Remember how half-shell is placed into world volume.

void	addLadderPlacement (VxdID halfShell, VxdID ladder, const G4Transform3D &placement)
	Remember how ladder is placed into half-shell.

void	addSensorPlacement (VxdID ladder, VxdID sensor, const G4Transform3D &placement)
	Remember how sensor is placed into ladder.

void	setupReconstructionTransformations ()
	Initialize from DB for reconstruction Updates all SensorInfo transformations for reconstruction from DB object(s) (recalculating new global positions) and registers itself for subsequent updates of DB objects to keep the hierarchy up-to-date.

const GeoTools *	getGeoTools ()
	Return a raw pointer to a GeoTools object.

Static Public Member Functions
static TGeoHMatrix	g4Transform3DToTGeo (const G4Transform3D &g4)
	Covenient function to convert G4Transform3D to TGeoHMatrix.

static TGeoHMatrix	getTGeoFromRigidBodyParams (double dU, double dV, double dW, double dAlpha, double dBeta, double dGamma)
	Convert 6 rigid body params (alignment corrections) to corresponding TGeoHMatrix Angles in radians, length units in centimeters.

static GeoCache &	getInstance ()
	Return a reference to the singleton instance.

Private Types
typedef std::unordered_map< VxdID::baseType, SensorInfoBase * >	SensorInfoMap
	Hash map to store pointers to all existing SensorInfos with constant lookup complexity.

typedef std::map< Belle2::VxdID, std::set< Belle2::VxdID > >	SensorHierachy
	Map to store a set of unique VxdIDs belonging to one VxdID.

Private Member Functions
	GeoCache ()
	Singleton class, hidden constructor.

	GeoCache (const GeoCache &)=delete
	Singleton class, hidden copy constructor.

GeoCache &	operator= (const GeoCache &)=delete
	Singleton class, hidden assignment operator.

Private Attributes
std::set< Belle2::VxdID >	m_pxdLayers
	Set of all PXD layer IDs.

std::set< Belle2::VxdID >	m_svdLayers
	Set of all SVD layer IDs.

std::set< Belle2::VxdID >	m_telLayers
	Set of all Tel layer IDs.

SensorHierachy	m_ladders
	Map of all Ladder IDs belonging to a given Layer ID.

SensorHierachy	m_sensors
	Map of all Sensor IDs belonging to a given Ladder ID.

std::map< VxdID, TGeoHMatrix >	m_halfShellPlacements {}
	Map of shell ids and their placements in top volume.

std::map< VxdID, std::vector< std::pair< VxdID, TGeoHMatrix > > >	m_ladderPlacements {}
	Map of shell ids and their associated ladder ids and their placements.

std::map< VxdID, std::vector< std::pair< VxdID, TGeoHMatrix > > >	m_sensorPlacements {}
	Map of ladder ids and their associated sensor ids and their placements.

SensorInfoMap	m_sensorInfo
	Map to find the SensorInfo for a given Sensor ID.

std::unique_ptr< GeoTools >	m_geoToolsPtr
	Pointer to a GeoTools object.

DBObjPtr< VXDAlignment >	m_vxdAlignments
	DBObjPtr for the alignment.

Detailed Description

Class to faciliate easy access to sensor information of the VXD like coordinate transformations or pitch size.

Definition at line 39 of file GeoCache.h.

Member Typedef Documentation

◆ SensorHierachy

typedef std::map<Belle2::VxdID, std::set<Belle2::VxdID> > SensorHierachy

private

Map to store a set of unique VxdIDs belonging to one VxdID.

Like ladders belong to layers, etc.

Definition at line 153 of file GeoCache.h.

◆ SensorInfoMap

typedef std::unordered_map<VxdID::baseType, SensorInfoBase*> SensorInfoMap

private

Hash map to store pointers to all existing SensorInfos with constant lookup complexity.

Definition at line 151 of file GeoCache.h.

Constructor & Destructor Documentation

◆ ~GeoCache()

~GeoCache ( )

inline

destructor to clean up structures

Definition at line 42 of file GeoCache.h.

42{ clear(); };

Belle2::VXD::GeoCache::clear

void clear()

Clean up internal structures.

Definition: GeoCache.cc:38

◆ GeoCache()

GeoCache ( )

private

Singleton class, hidden constructor.

Definition at line 32 of file GeoCache.cc.

    {
      // Add callback to update ReconstructionTransformation whenever alignment changes
      m_vxdAlignments.addCallback(this, &VXD::GeoCache::setupReconstructionTransformations);
    }

Member Function Documentation

◆ addHalfShellPlacement()

void addHalfShellPlacement	(	VxdID	halfShell,
		const G4Transform3D &	placement
	)

Remember how half-shell is placed into world volume.

Definition at line 232 of file GeoCache.cc.

    {
      m_halfShellPlacements[halfShell] = g4Transform3DToTGeo(placement);
      // Add the (empty) container for ladder placements inside this halfshell
      m_ladderPlacements[halfShell] = std::vector<std::pair<VxdID, TGeoHMatrix>>();
    }

◆ addLadderPlacement()

void addLadderPlacement	(	VxdID	halfShell,
		VxdID	ladder,
		const G4Transform3D &	placement
	)

Remember how ladder is placed into half-shell.

Definition at line 225 of file GeoCache.cc.

    {
      m_ladderPlacements[halfShell].push_back(std::make_pair(ladder, g4Transform3DToTGeo(placement)));
      // Add the (empty) container for sensor placements inside this ladder
      m_sensorPlacements[ladder] = std::vector<std::pair<VxdID, TGeoHMatrix>>();
    }

◆ addSensor()

void addSensor ( SensorInfoBase * sensorinfo )

Add a SensorInfo instance to the list of known sensors This method will manually add a SensorInfo instance to the list of known sensors.

It should not be needed except for testing purposes.

Parameters

sensorinfo SensorInfoBase instance to add to the list of known sensors.

Definition at line 147 of file GeoCache.cc.

    {
      //Save pointer to the SensorInfo and update lists of all existing
      //layers,ladders,sensors
      VxdID sensorID = sensorinfo->getID();
      VxdID ladderID = sensorID;
      ladderID.setSensorNumber(0);
      VxdID layerID  = ladderID;
      layerID.setLadderNumber(0);
 
      m_sensorInfo[sensorID] = sensorinfo;
 
      switch (sensorinfo->getType()) {
        case SensorInfoBase::PXD:
          m_pxdLayers.insert(layerID);
          break;
        case SensorInfoBase::SVD:
          m_svdLayers.insert(layerID);
          break;
        case SensorInfoBase::TEL:
          m_telLayers.insert(layerID);
          break;
        default:
          B2FATAL("Cannot use anything else as SensorTypes PXD, SVD, or TEL when creating VXD Sensors");
      }
      m_ladders[layerID].insert(ladderID);
      m_sensors[ladderID].insert(sensorID);
    }

◆ addSensorPlacement()

void addSensorPlacement	(	VxdID	ladder,
		VxdID	sensor,
		const G4Transform3D &	placement
	)

Remember how sensor is placed into ladder.

Definition at line 220 of file GeoCache.cc.

    {
      m_sensorPlacements[ladder].push_back(std::make_pair(sensor, g4Transform3DToTGeo(placement)));
    }

◆ clear()

void clear ( )

Clean up internal structures.

Definition at line 38 of file GeoCache.cc.

    {
      m_pxdLayers.clear();
      m_svdLayers.clear();
      m_telLayers.clear();
      m_ladders.clear();
      m_sensors.clear();
      m_sensorInfo.clear();
 
      m_halfShellPlacements.clear();
      m_ladderPlacements.clear();
      m_sensorPlacements.clear();
    }

◆ findVolumes()

void findVolumes ( G4VPhysicalVolume * envelope )

Search a given Geometry for Sensors.

This method will search a given Physical Volume and add all sensitive Volumes where the SensitiveDetector implementation inherits from vxd::SensitiveDetector to the cache.

The given volume must be a volume placed directly in the top volume, otherwise the transformations cannot be determined correctly.

This method should be called by the geometry creator once all sensitive volumes are placed

Parameters

envelope Geometry tree to search, usually the Envelope of PXD or SVD

Definition at line 78 of file GeoCache.cc.

    {
      //So, lets loop over the geometry tree and find all sensitive volumes.
      //To get the correct Transformation matrices we use the
      //G4NavigationHistory which is a stack of premultiplied transformations.
      G4NavigationHistory nav;
      //To avoid recursion we store all volumes in a stack, starting with the
      //envelope we are about to search in
      stack<G4VPhysicalVolume*> volumes;
      volumes.push(envelope);
 
      //Now lets just continue until the stack is empty
      while (!volumes.empty()) {
        G4VPhysicalVolume* physical = volumes.top();
        volumes.pop();
        //NULL indicates that we are finished with the children of a node, so
        //pop a transformation level
        if (!physical) {
          nav.BackLevel();
          continue;
        }
        //Add a NULL to so that we know that all children are finished once we
        //emptied the stack of volumes back to this NULL
        volumes.push(0);
        //Now enter the volume
        nav.NewLevel(physical);
 
        G4LogicalVolume* logical = physical->GetLogicalVolume();
 
        //Check if we found a sensitive volume with correct type
        SensitiveDetectorBase* sensitive = dynamic_cast<SensitiveDetectorBase*>(logical->GetSensitiveDetector());
        if (sensitive) {
          //Apparently we did, so get the sensor Information and add it
          SensorInfoBase* info = sensitive->getSensorInfo();
          if (!info) B2FATAL("No SensorInfo found for Volume " << logical->GetName());
 
          //Convert transformation to ROOT
          const G4AffineTransform g4transform = nav.GetTopTransform().Inverse();
          TGeoHMatrix transform;
          double rotation[9] = {
            g4transform[0], g4transform[4], g4transform[8],
            g4transform[1], g4transform[5], g4transform[9],
            g4transform[2], g4transform[6], g4transform[10]
          };
          transform.SetRotation(rotation);
          transform.SetDx(g4transform[12]*Unit::mm);
          transform.SetDy(g4transform[13]*Unit::mm);
          transform.SetDz(g4transform[14]*Unit::mm);
          info->setTransformation(transform); // cppcheck-suppress nullPointerRedundantCheck
          info->setTransformation(transform, true); // cppcheck-suppress nullPointerRedundantCheck
 
          addSensor(info);
        }
 
        int nDaughters = logical->GetNoDaughters();
        //Add all children. Since we use a stack they will be processed in
        //opposite order In principle we do not care, but for niceness sake we
        //add them back to front so that they are processed in the "correct"
        //order
        for (int i = nDaughters - 1; i >= 0; --i) {
          G4VPhysicalVolume* daughter = logical->GetDaughter(i);
          volumes.push(daughter);
        }
      }
 
      // Finally set-up reconstruction transformations
      setupReconstructionTransformations();
    }

◆ g4Transform3DToTGeo()

TGeoHMatrix g4Transform3DToTGeo ( const G4Transform3D & g4 )

static

Covenient function to convert G4Transform3D to TGeoHMatrix.

Definition at line 349 of file GeoCache.cc.

    {
      TGeoHMatrix trafo;
      // Differential translation
      TGeoTranslation translation;
      // Differential rotation
      TGeoRotation rotation;
 
      //NOTE: for some reason, there is cm vs. mm difference
      trafo.SetDx(g4.getTranslation()[0] / 10.);
      trafo.SetDy(g4.getTranslation()[1] / 10.);
      trafo.SetDz(g4.getTranslation()[2] / 10.);
 
      Double_t rotMatrix[9];
      for (int i = 0; i < 3; ++i) {
        for (int j = 0; j < 3; ++j) {
          rotMatrix[i * 3 + j] = g4.getRotation()[i][j];
        }
      }
      trafo.SetRotation(rotMatrix);
      return trafo;
    }

◆ getGeoTools()

const GeoTools * getGeoTools ( )

inline

Return a raw pointer to a GeoTools object.

Returns: const GeoTools* : raw pointer, no onwership transfer

Definition at line 142 of file GeoCache.h.

      {
        if (!m_geoToolsPtr)
          m_geoToolsPtr = std::unique_ptr<GeoTools>(new GeoTools());
        return m_geoToolsPtr.get();
      }

◆ getHalfShellPlacements()

const map< VxdID, TGeoHMatrix > & getHalfShellPlacements ( ) const

Retrieve stored half-shell placements into world volume.

Returns: map of VxdID for half-shell and its placement

Definition at line 239 of file GeoCache.cc.

239{return m_halfShellPlacements;}

◆ getInstance()

GeoCache & getInstance ( )

static

Return a reference to the singleton instance.

Definition at line 214 of file GeoCache.cc.

    {
      static unique_ptr<GeoCache> instance(new GeoCache());
      return *instance;
    }

◆ getLadderPlacements()

const vector< pair< VxdID, TGeoHMatrix > > & getLadderPlacements ( VxdID halfShell ) const

Retrieve stored ladder placements into half-shell.

Returns: vector of pairs, each pair contains a VxdID for ladder (layer.ladder.0) and its placement

Definition at line 250 of file GeoCache.cc.

    {
      auto placements = m_ladderPlacements.find(halfShell);
      if (placements == m_ladderPlacements.end())
        throw std::invalid_argument("Invalid half-shelve id " + (std::string) halfShell);
 
      return placements->second;
    }

◆ getLadders()

const set< VxdID > & getLadders ( Belle2::VxdID layer ) const

Return a set of all ladder IDs belonging to a given layer.

Definition at line 193 of file GeoCache.cc.

    {
      //We only index by layer, so set everything else to 0
      layer.setLadderNumber(0);
      layer.setSensorNumber(0);
      layer.setSegmentNumber(0);
      SensorHierachy::const_iterator info = m_ladders.find(layer);
      if (info == m_ladders.end()) B2FATAL("VXD Layer " << layer << "does not exist.");
      return info->second;
    }

◆ getLayers()

const set< VxdID > getLayers ( SensorInfoBase::SensorType sensortype = SensorInfoBase::VXD )

Return a set of all known Layers.

Parameters

sensortype Wether to only return the layer IDs for PXD, SVD or all VXD layers (default)

Returns: a set containing all existing Layers with the requested type

Definition at line 176 of file GeoCache.cc.

    {
      switch (type) {
        case SensorInfoBase::PXD:
          return m_pxdLayers;
        case SensorInfoBase::SVD:
          return m_svdLayers;
        case SensorInfoBase::TEL:
          return m_telLayers;
        default:
          std::set<VxdID> allLayers = m_pxdLayers;
          allLayers.insert(m_svdLayers.begin(), m_svdLayers.end());
          allLayers.insert(m_telLayers.begin(), m_telLayers.end());
          return allLayers;
      }
    }

◆ getListOfSensors()

const vector< VxdID > getListOfSensors ( ) const

Get list of all sensors.

Intended mostly for Python, where std::sets don't work.

Returns: vector of VxdIDs of all sensors in GeoCache.

Definition at line 59 of file GeoCache.cc.

    {
      vector<VxdID> sensors;
      for (auto entry : m_sensorInfo)
        sensors.push_back(entry.first);
      return sensors;
    }

◆ getSensorInfo()

const SensorInfoBase & getSensorInfo ( Belle2::VxdID id ) const

Return a referecne to the SensorInfo of a given SensorID.

Definition at line 67 of file GeoCache.cc.

    {
      id.setSegmentNumber(0);
      SensorInfoMap::const_iterator info = m_sensorInfo.find(id);
      if (info == m_sensorInfo.end()) {
        B2WARNING("VXD Sensor " << id << " does not exist.");
        return *(m_sensorInfo.begin()->second);
      }
      return *(info->second);
    }

◆ getSensorPlacements()

const vector< pair< VxdID, TGeoHMatrix > > & getSensorPlacements ( VxdID ladder ) const

Retrieve stored sensor placements into ladders.

Returns: vector of pairs, each pair contains a VxdID for sensor and its placement

Definition at line 241 of file GeoCache.cc.

    {
      auto placements = m_sensorPlacements.find(ladder);
      if (placements == m_sensorPlacements.end())
        throw std::invalid_argument("Invalid ladder id " + (std::string) ladder);
 
      return placements->second;
    }

◆ getSensors()

const set< VxdID > & getSensors ( Belle2::VxdID ladder ) const

Return a set of all sensor IDs belonging to a given ladder.

Definition at line 204 of file GeoCache.cc.

    {
      //We only index by layer and ladder, set sensor to 0
      ladder.setSensorNumber(0);
      ladder.setSegmentNumber(0);
      SensorHierachy::const_iterator info = m_sensors.find(ladder);
      if (info == m_sensors.end()) B2FATAL("VXD Ladder " << ladder << "does not exist.");
      return info->second;
    }

◆ getTGeoFromRigidBodyParams()

TGeoHMatrix getTGeoFromRigidBodyParams	(	double	dU,
		double	dV,
		double	dW,
		double	dAlpha,
		double	dBeta,
		double	dGamma
	)

static

Convert 6 rigid body params (alignment corrections) to corresponding TGeoHMatrix Angles in radians, length units in centimeters.

Definition at line 372 of file GeoCache.cc.

    {
      // Differential translation
      TGeoTranslation translation;
      // Differential rotation
      TGeoRotation rotation;
 
      translation.SetTranslation(dU, dV, dW);
      rotation.RotateX(- dAlpha * TMath::RadToDeg());
      rotation.RotateY(- dBeta  * TMath::RadToDeg());
      rotation.RotateZ(- dGamma * TMath::RadToDeg());
 
      // Differential trafo (trans + rot)
      TGeoCombiTrans combi(translation, rotation);
      TGeoHMatrix trafo;
      trafo = trafo * combi;
      return trafo;
    }

◆ setupReconstructionTransformations()

void setupReconstructionTransformations ( )

Initialize from DB for reconstruction Updates all SensorInfo transformations for reconstruction from DB object(s) (recalculating new global positions) and registers itself for subsequent updates of DB objects to keep the hierarchy up-to-date.

So the hierarchy is as follows: Belle 2 / | | \ Ying Yang Pat Mat ... other sub-detectors / | / | | \ | \ ...... ladders ...... / / | / | | \ | \ \ ......... sensors ........

Definition at line 259 of file GeoCache.cc.

    {
      if (!m_vxdAlignments.isValid()) {
        B2WARNING("No VXD alignment data. Defaults (0's) will be used!");
        return;
      }
 
      // Loop over VXD sensors to read parameters for description of planar defomration
      for (auto& sensorID : getListOfSensors()) {
        std::vector<double> planarParameters = {
          // Numbering of VXD alignment parameters:
          //  -> 0-6:   Rigid body alignment
          //  -> 31-33: First level of surface deformation
          //  -> 41-44: Second level of surface deformation
          //  -> 51-55: Third level of surface deformation
          m_vxdAlignments->get(sensorID, 31),
          m_vxdAlignments->get(sensorID, 32),
          m_vxdAlignments->get(sensorID, 33),
          m_vxdAlignments->get(sensorID, 41),
          m_vxdAlignments->get(sensorID, 42),
          m_vxdAlignments->get(sensorID, 43),
          m_vxdAlignments->get(sensorID, 44),
          m_vxdAlignments->get(sensorID, 51),
          m_vxdAlignments->get(sensorID, 52),
          m_vxdAlignments->get(sensorID, 53),
          m_vxdAlignments->get(sensorID, 54),
          m_vxdAlignments->get(sensorID, 55),
        };
 
        // Store parameters for planar deformation
        VXD::SensorInfoBase& sensorInfo = const_cast<VXD::SensorInfoBase&>(getSensorInfo(sensorID));
        sensorInfo.setSurfaceParameters(planarParameters);
      }
 
      for (auto& halfShellPlacement : getHalfShellPlacements()) {
        TGeoHMatrix trafoHalfShell = halfShellPlacement.second;
        trafoHalfShell *= getTGeoFromRigidBodyParams(
                            m_vxdAlignments->get(halfShellPlacement.first, VXDAlignment::dU),
                            m_vxdAlignments->get(halfShellPlacement.first, VXDAlignment::dV),
                            m_vxdAlignments->get(halfShellPlacement.first, VXDAlignment::dW),
                            m_vxdAlignments->get(halfShellPlacement.first, VXDAlignment::dAlpha),
                            m_vxdAlignments->get(halfShellPlacement.first, VXDAlignment::dBeta),
                            m_vxdAlignments->get(halfShellPlacement.first, VXDAlignment::dGamma)
                          );
 
        for (auto& ladderPlacement : getLadderPlacements(halfShellPlacement.first)) {
          // Updated trafo
          TGeoHMatrix trafoLadder = ladderPlacement.second;
          trafoLadder *= getTGeoFromRigidBodyParams(
                           m_vxdAlignments->get(ladderPlacement.first, VXDAlignment::dU),
                           m_vxdAlignments->get(ladderPlacement.first, VXDAlignment::dV),
                           m_vxdAlignments->get(ladderPlacement.first, VXDAlignment::dW),
                           m_vxdAlignments->get(ladderPlacement.first, VXDAlignment::dAlpha),
                           m_vxdAlignments->get(ladderPlacement.first, VXDAlignment::dBeta),
                           m_vxdAlignments->get(ladderPlacement.first, VXDAlignment::dGamma)
                         );
 
          for (auto& sensorPlacement : getSensorPlacements(ladderPlacement.first)) {
            // Updated trafo
            TGeoHMatrix trafoSensor = sensorPlacement.second;
            trafoSensor *= getTGeoFromRigidBodyParams(
                             m_vxdAlignments->get(sensorPlacement.first, VXDAlignment::dU),
                             m_vxdAlignments->get(sensorPlacement.first, VXDAlignment::dV),
                             m_vxdAlignments->get(sensorPlacement.first, VXDAlignment::dW),
                             m_vxdAlignments->get(sensorPlacement.first, VXDAlignment::dAlpha),
                             m_vxdAlignments->get(sensorPlacement.first, VXDAlignment::dBeta),
                             m_vxdAlignments->get(sensorPlacement.first, VXDAlignment::dGamma)
                           );
 
            // Store new reco-transformation
            VXD::SensorInfoBase& geometry = const_cast<VXD::SensorInfoBase&>(getSensorInfo(sensorPlacement.first));
            geometry.setTransformation(trafoHalfShell * trafoLadder * trafoSensor, true);
 
          }
        }
      }
 
    }

◆ validSensorID()

bool validSensorID ( Belle2::VxdID id ) const

Check that id is a valid sensor number.

Parameters

id	sensor id to be checked against current GeoCache information

Returns: true if there is a SensorInfo associated with id, otherwise false.

Definition at line 52 of file GeoCache.cc.

    {
      id.setSegmentNumber(0);
      SensorInfoMap::const_iterator info = m_sensorInfo.find(id);
      return (info != m_sensorInfo.end());
    }

Member Data Documentation

◆ m_geoToolsPtr

std::unique_ptr<GeoTools> m_geoToolsPtr

private

Pointer to a GeoTools object.

Definition at line 183 of file GeoCache.h.

◆ m_halfShellPlacements

std::map<VxdID, TGeoHMatrix> m_halfShellPlacements {}

private

Map of shell ids and their placements in top volume.

Definition at line 174 of file GeoCache.h.

◆ m_ladderPlacements

std::map<VxdID, std::vector<std::pair<VxdID, TGeoHMatrix> > > m_ladderPlacements {}

private

Map of shell ids and their associated ladder ids and their placements.

Definition at line 176 of file GeoCache.h.

◆ m_ladders

SensorHierachy m_ladders

private

Map of all Ladder IDs belonging to a given Layer ID.

Definition at line 169 of file GeoCache.h.

◆ m_pxdLayers

std::set<Belle2::VxdID> m_pxdLayers

private

Set of all PXD layer IDs.

Definition at line 163 of file GeoCache.h.

◆ m_sensorInfo

SensorInfoMap m_sensorInfo

private

Map to find the SensorInfo for a given Sensor ID.

Definition at line 180 of file GeoCache.h.

◆ m_sensorPlacements

std::map<VxdID, std::vector<std::pair<VxdID, TGeoHMatrix> > > m_sensorPlacements {}

private

Map of ladder ids and their associated sensor ids and their placements.

Definition at line 178 of file GeoCache.h.

◆ m_sensors

SensorHierachy m_sensors

private

Map of all Sensor IDs belonging to a given Ladder ID.

Definition at line 171 of file GeoCache.h.

◆ m_svdLayers

std::set<Belle2::VxdID> m_svdLayers

private

Set of all SVD layer IDs.

Definition at line 165 of file GeoCache.h.

◆ m_telLayers

std::set<Belle2::VxdID> m_telLayers

private

Set of all Tel layer IDs.

Definition at line 167 of file GeoCache.h.

◆ m_vxdAlignments

DBObjPtr<VXDAlignment> m_vxdAlignments

private

DBObjPtr for the alignment.

Definition at line 186 of file GeoCache.h.

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

vxd/geometry/include/GeoCache.h
vxd/geometry/src/GeoCache.cc

Public Member Functions

Static Public Member Functions

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ SensorHierachy

◆ SensorInfoMap

Constructor & Destructor Documentation

◆ ~GeoCache()

◆ GeoCache()

Member Function Documentation

◆ addHalfShellPlacement()

◆ addLadderPlacement()

◆ addSensor()

◆ addSensorPlacement()

◆ clear()

◆ findVolumes()

◆ g4Transform3DToTGeo()

◆ getGeoTools()

◆ getHalfShellPlacements()

◆ getInstance()

◆ getLadderPlacements()

◆ getLadders()

◆ getLayers()

◆ getListOfSensors()

◆ getSensorInfo()

◆ getSensorPlacements()

◆ getSensors()

◆ getTGeoFromRigidBodyParams()

◆ setupReconstructionTransformations()

◆ validSensorID()

Member Data Documentation

◆ m_geoToolsPtr

◆ m_halfShellPlacements

◆ m_ladderPlacements

◆ m_ladders

◆ m_pxdLayers

◆ m_sensorInfo

◆ m_sensorPlacements

◆ m_sensors

◆ m_svdLayers

◆ m_telLayers

◆ m_vxdAlignments