InDet::DiscOverlapDescriptor Class Reference

Class to describe overlaps in the custom detector, it extends the Trk::OverlapDescriptor base class. More...

#include <DiscOverlapDescriptor.h>

Inheritance diagram for InDet::DiscOverlapDescriptor:

Collaboration diagram for InDet::DiscOverlapDescriptor:

Public Member Functions
	DiscOverlapDescriptor ()=default
	DiscOverlapDescriptor (const Trk::BinnedArray< Trk::Surface > *bin_array, const std::vector< Trk::BinUtility > &singleBinUtils, bool isPixel=false)
	Constructor.
virtual	~DiscOverlapDescriptor ()=default
	Destructor.
	DiscOverlapDescriptor (const DiscOverlapDescriptor &)=delete
	Delete copy.
DiscOverlapDescriptor &	operator= (const DiscOverlapDescriptor &)=delete
	Delete assignment.
virtual DiscOverlapDescriptor *	clone () const override
	Pseudo-Constructor.
bool	reachableSurfaces (std::vector< Trk::SurfaceIntersection > &surfaces, const Trk::Surface &sf, const Amg::Vector3D &pos, const Amg::Vector3D &dir) const override
	get the compatible surfaces

Private Member Functions
bool	dumpSurfaces (std::vector< Trk::SurfaceIntersection > &surfaces) const

Private Attributes
const Trk::BinnedArray< Trk::Surface > *	m_bin_array {nullptr}
std::vector< Trk::BinUtility >	m_singleBinUtils {}
bool	m_pixelCase {false}

Detailed Description

Class to describe overlaps in the custom detector, it extends the Trk::OverlapDescriptor base class.

There are two interface methods, one provides the most probably overlapcell, the second provides a list of overlap cells, based on an restricted area

Author

Noemi.nosp@m..Cal.nosp@m.ace@c.nosp@m.ern..nosp@m.ch

Definition at line 79 of file DiscOverlapDescriptor.h.

Constructor & Destructor Documentation

DiscOverlapDescriptor() [1/3]

InDet::DiscOverlapDescriptor::DiscOverlapDescriptor ( )

default

DiscOverlapDescriptor() [2/3]

InDet::DiscOverlapDescriptor::DiscOverlapDescriptor	(	const Trk::BinnedArray< Trk::Surface > *	bin_array,
		const std::vector< Trk::BinUtility > &	singleBinUtils,
		bool	isPixel = false )

Constructor.

Definition at line 63 of file DiscOverlapDescriptor.cxx.

                                                                 :
  m_bin_array(bin_array),
  m_singleBinUtils(singleBinUtils),
  m_pixelCase(isPixel)
{}

~DiscOverlapDescriptor()

virtual InDet::DiscOverlapDescriptor::~DiscOverlapDescriptor ( )

virtualdefault

Destructor.

DiscOverlapDescriptor() [3/3]

InDet::DiscOverlapDescriptor::DiscOverlapDescriptor ( const DiscOverlapDescriptor & )

delete

Delete copy.

Member Function Documentation

clone()

DiscOverlapDescriptor * InDet::DiscOverlapDescriptor::clone ( ) const

inlineoverridevirtual

Pseudo-Constructor.

Implements Trk::OverlapDescriptor.

Definition at line 116 of file DiscOverlapDescriptor.h.

{ return new DiscOverlapDescriptor(); }

dumpSurfaces()

bool InDet::DiscOverlapDescriptor::dumpSurfaces ( std::vector< Trk::SurfaceIntersection > & surfaces ) const

private

Definition at line 239 of file DiscOverlapDescriptor.cxx.

                                                                                               {
  std::cout << "Dumping Surfaces for " << (m_pixelCase ? "Pixel " : "SCT ")
            << "with size = " << surfaces.size() << std::endl;
  static const StoreGateSvc* const detStore = getDetStore();
  static const PixelID* const pixIdHelper = getPixelID(detStore);
  static const SCT_ID* const sctIdHelper = getSCT_ID(detStore);
 
  for (auto & surface : surfaces) {
    Identifier hitId = (surface.object)->associatedDetectorElementIdentifier();
    if (m_pixelCase)
      std::cout <<  "barrel_ec " << pixIdHelper->barrel_ec(hitId)
                << ", layer_disk " << pixIdHelper->layer_disk(hitId)
                << ", phi_module " << pixIdHelper->phi_module(hitId)
                << ", eta_module " << pixIdHelper->eta_module(hitId) << std::endl;
    else
      std::cout <<  "barrel_ec " << sctIdHelper->barrel_ec(hitId)
                << ", layer_disk " << sctIdHelper->layer_disk(hitId)
                << ", phi_module " << sctIdHelper->phi_module(hitId)
                << ", eta_module " << sctIdHelper->eta_module(hitId)
                << ", side " << sctIdHelper->side(hitId) << std::endl;
  }
  return true;
}

operator=()

DiscOverlapDescriptor & InDet::DiscOverlapDescriptor::operator= ( const DiscOverlapDescriptor & )

delete

Delete assignment.

reachableSurfaces()

bool InDet::DiscOverlapDescriptor::reachableSurfaces ( std::vector< Trk::SurfaceIntersection > & surfaces, const Trk::Surface & sf, const Amg::Vector3D & pos, const Amg::Vector3D & dir ) const

overridevirtual

get the compatible surfaces

• return vector : surfaces
• primary bin surface : sf
• position & direction : pos, dir

Implements Trk::OverlapDescriptor.

Definition at line 71 of file DiscOverlapDescriptor.cxx.

{ //These are done once no matter how many
  //instances of DiscOverlapDescriptor we have
  static const StoreGateSvc* const detStore = getDetStore();
  static const PixelID* const pixIdHelper = getPixelID(detStore);
  static const SCT_ID* const sctIdHelper = getSCT_ID(detStore);
 
  // get the according detector element
  const InDetDD::SiDetectorElement* pElement  = dynamic_cast<const InDetDD::SiDetectorElement*>(tsf.associatedDetectorElement());
 
  // first add the target surface
  surfaces.emplace_back(Trk::Intersection(pos, 0., true),&tsf);
  int etaModule =
    m_pixelCase
      ? pixIdHelper->eta_module(tsf.associatedDetectorElementIdentifier())
      : sctIdHelper->eta_module(tsf.associatedDetectorElementIdentifier());
 
  // return empty cell vector
  if (pElement) {
    size_t newCapacity = surfaces.size() + 19;
    if (pElement->otherSide()) newCapacity += 19;
    surfaces.reserve(newCapacity);
 
    addOtherSideDO(pElement,surfaces);
 
    addNextInPhiDO(pElement,surfaces);
    addPrevInPhiDO(pElement,surfaces);
 
    addNextInPhiDO(pElement->nextInPhi(),surfaces);
    addPrevInPhiDO(pElement->prevInPhi(),surfaces);
 
    // First use the bin utiliy to find the surfaces on the same disc but in different rings
    // This is done as follows:
    // 1 -> Find at which bin corresponds the surface, i.e. at which ring on the disc it corresponds
    // 2 -> If it is not 0 (i.e. the surface doesn't belong to the innermost ring),
    // look for the surfaces in the ring with smaller eta value (it returns 2 or 3 surfaces)
    // 3 -> If it is smaller than the number of rings (i.e. the surface doen't belong to the outermost ring),
    // look for the surfaces in the ring with bigger eta value (it returns 2 or 3 surfaces)//
 
    if (m_bin_array && !m_singleBinUtils.empty()){
 
      const Trk::Surface* samePhi_PrevEta     = nullptr;
      const Trk::Surface* samePhi_NextEta     = nullptr;
 
      const Trk::Surface* previousPhi_PrevEta = nullptr;
      const Trk::Surface* nextPhi_PrevEta     = nullptr;
 
      const Trk::Surface* previousPhi_NextEta = nullptr;
      const Trk::Surface* nextPhi_NextEta     = nullptr;
 
      std::span<Trk::Surface const * const> surf = m_bin_array->arrayObjects();
      size_t offset = 0;
      for (unsigned int bin = 0; bin < m_singleBinUtils.size(); bin++) {
        int etamod =
          m_pixelCase
            ? pixIdHelper->eta_module(
                (*(surf[offset])).associatedDetectorElementIdentifier())
            : sctIdHelper->eta_module(
                (*(surf[offset])).associatedDetectorElementIdentifier());
 
        if (etamod == etaModule || etamod < (etaModule - 1) ||
            etamod > (etaModule + 1)) {
          offset += (std::as_const(m_singleBinUtils).at(bin)).bins();
          continue;
        }
 
        double PrevDeltaPhi = 9999.;
        double NextDeltaPhi = -9999.;
        for (unsigned int ss = offset; ss < (offset+(std::as_const(m_singleBinUtils).at(bin)).bins()); ss++ ) {
          if (etamod == (etaModule-1) ) {
            if( tsf.center().phi() == (*(surf[ss])).center().phi() )
              samePhi_PrevEta = surf[ss];
            double DeltaPhi = tsf.center().phi() - (*(surf[ss])).center().phi();
            if( DeltaPhi < PrevDeltaPhi && DeltaPhi > 0) {
              previousPhi_PrevEta = surf[ss];
              PrevDeltaPhi = DeltaPhi;
            }
            if( DeltaPhi > NextDeltaPhi && DeltaPhi < 0) {
              nextPhi_PrevEta = surf[ss];
              NextDeltaPhi = DeltaPhi;
            }
          } else if (etamod == (etaModule+1) ) {
            if( tsf.center().phi() == (*(surf[ss])).center().phi() )
              samePhi_NextEta = surf[ss];
            double DeltaPhi = tsf.center().phi() - (*(surf[ss])).center().phi();
            if( DeltaPhi < PrevDeltaPhi && DeltaPhi > 0) {
              previousPhi_NextEta = surf[ss];
              PrevDeltaPhi = DeltaPhi;
            }
 
            if( DeltaPhi > NextDeltaPhi && DeltaPhi < 0) {
              nextPhi_NextEta = surf[ss];
              NextDeltaPhi = DeltaPhi;
            }
          }
        }
        offset += (std::as_const(m_singleBinUtils).at(bin)).bins();
      }
 
      if (samePhi_PrevEta) {
        const InDetDD::SiDetectorElement* PhiEta_Element = dynamic_cast<const InDetDD::SiDetectorElement*>(samePhi_PrevEta->associatedDetectorElement());
        if (PhiEta_Element) {
          addSurfaceDO(PhiEta_Element,surfaces);
          addOtherSideDO(PhiEta_Element, surfaces);
        }
      }
 
      if (previousPhi_PrevEta) {
        const InDetDD::SiDetectorElement* PhiEta_Element = dynamic_cast<const InDetDD::SiDetectorElement*>(previousPhi_PrevEta->associatedDetectorElement());
        if (PhiEta_Element) {
          addSurfaceDO(PhiEta_Element,surfaces);
          addOtherSideDO(PhiEta_Element, surfaces);
 
          addPrevInPhiDO(PhiEta_Element,surfaces);
          addPrevInPhiDO(PhiEta_Element->prevInPhi(),surfaces);
        }
      }
 
      if (nextPhi_PrevEta) {
        const InDetDD::SiDetectorElement* PhiEta_Element = dynamic_cast<const InDetDD::SiDetectorElement*>(nextPhi_PrevEta->associatedDetectorElement());
        if (PhiEta_Element) {
          addSurfaceDO(PhiEta_Element,surfaces);
          addOtherSideDO(PhiEta_Element, surfaces);
 
          addNextInPhiDO(PhiEta_Element,surfaces);
          addNextInPhiDO(PhiEta_Element->nextInPhi(),surfaces);
        }
      }
 
      if (samePhi_NextEta) {
        const InDetDD::SiDetectorElement* PhiEta_Element = dynamic_cast<const InDetDD::SiDetectorElement*>(samePhi_NextEta->associatedDetectorElement());
        if (PhiEta_Element) {
          addSurfaceDO(PhiEta_Element,surfaces);
          addOtherSideDO(PhiEta_Element, surfaces);
        }
      }
 
      if (previousPhi_NextEta) {
        const InDetDD::SiDetectorElement* PhiEta_Element = dynamic_cast<const InDetDD::SiDetectorElement*>(previousPhi_NextEta->associatedDetectorElement());
        if (PhiEta_Element) {
          addSurfaceDO(PhiEta_Element,surfaces);
          addOtherSideDO(PhiEta_Element, surfaces);
 
          addPrevInPhiDO(PhiEta_Element,surfaces);
          addPrevInPhiDO(PhiEta_Element->prevInPhi(),surfaces);
        }
      }
 
      if (nextPhi_NextEta) {
        const InDetDD::SiDetectorElement* PhiEta_Element = dynamic_cast<const InDetDD::SiDetectorElement*>(nextPhi_NextEta->associatedDetectorElement());
        if (PhiEta_Element) {
          addSurfaceDO(PhiEta_Element,surfaces);
          addOtherSideDO(PhiEta_Element, surfaces);
 
          addNextInPhiDO(PhiEta_Element,surfaces);
          addNextInPhiDO(PhiEta_Element->nextInPhi(),surfaces);
        }
      }
    }
  }
 
  return false;
 
}

Member Data Documentation

m_bin_array

const Trk::BinnedArray<Trk::Surface>* InDet::DiscOverlapDescriptor::m_bin_array {nullptr}

private

Definition at line 111 of file DiscOverlapDescriptor.h.

{nullptr};

m_pixelCase

bool InDet::DiscOverlapDescriptor::m_pixelCase {false}

private

Definition at line 113 of file DiscOverlapDescriptor.h.

{false};

m_singleBinUtils

std::vector<Trk::BinUtility> InDet::DiscOverlapDescriptor::m_singleBinUtils {}

private

Definition at line 112 of file DiscOverlapDescriptor.h.

{};

---

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

• DiscOverlapDescriptor.h
• DiscOverlapDescriptor.cxx