HGTD_OverlapDescriptor Class Reference

Class to describe overlaps in the HGTD detector. More...

#include <HGTD_OverlapDescriptor.h>

Inheritance diagram for HGTD_OverlapDescriptor:

Collaboration diagram for HGTD_OverlapDescriptor:

Public Member Functions
	HGTD_OverlapDescriptor (const Trk::BinnedArray< Trk::Surface > *bin_array=nullptr, std::vector< float > valuesR={}, std::vector< std::vector< float > > valuesPhi={}, int nStepsR=3, int nStepsPhi=10)
	Constructor.
virtual	~HGTD_OverlapDescriptor ()
	Destructor.
	HGTD_OverlapDescriptor (const HGTD_OverlapDescriptor &)=delete
	Delete copy.
HGTD_OverlapDescriptor &	operator= (const HGTD_OverlapDescriptor &)=delete
	Delete assignment.
virtual HGTD_OverlapDescriptor *	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_binnedArray
std::vector< float >	m_valuesR
std::vector< std::vector< float > >	m_valuesPhi
int	m_nStepsR
int	m_nStepsPhi
std::atomic< const HGTD_ID * >	m_hgtdIdHelper {nullptr}

Detailed Description

Class to describe overlaps in the HGTD 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

Definition at line 39 of file HGTD_OverlapDescriptor.h.

Constructor & Destructor Documentation

HGTD_OverlapDescriptor() [1/2]

HGTD_OverlapDescriptor::HGTD_OverlapDescriptor	(	const Trk::BinnedArray< Trk::Surface > *	bin_array = nullptr,
		std::vector< float >	valuesR = {},
		std::vector< std::vector< float > >	valuesPhi = {},
		int	nStepsR = 3,
		int	nStepsPhi = 10 )

Constructor.

Definition at line 24 of file HGTD_OverlapDescriptor.cxx.

                                                                          :
  m_binnedArray(bin_array),
  m_valuesR(std::move(valuesR)),
  m_valuesPhi(std::move(valuesPhi)),
  m_nStepsR(nStepsR),
  m_nStepsPhi(nStepsPhi)
{}

~HGTD_OverlapDescriptor()

virtual HGTD_OverlapDescriptor::~HGTD_OverlapDescriptor ( )

inlinevirtual

Destructor.

Definition at line 49 of file HGTD_OverlapDescriptor.h.

                                    {
  }

HGTD_OverlapDescriptor() [2/2]

HGTD_OverlapDescriptor::HGTD_OverlapDescriptor ( const HGTD_OverlapDescriptor & )

delete

Delete copy.

Member Function Documentation

clone()

HGTD_OverlapDescriptor * HGTD_OverlapDescriptor::clone ( ) const

inlineoverridevirtual

Pseudo-Constructor.

Implements Trk::OverlapDescriptor.

Definition at line 84 of file HGTD_OverlapDescriptor.h.

                                                                   {
  return new HGTD_OverlapDescriptor();
}

dumpSurfaces()

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

private

Definition at line 88 of file HGTD_OverlapDescriptor.cxx.

                                                                                           {
  
  if (m_hgtdIdHelper==nullptr) {
    // Get Storegate, ID helpers, and so on
    ISvcLocator* svcLocator = Gaudi::svcLocator();
    
    // get DetectorStore service
    SmartIF<StoreGateSvc> detStore{svcLocator->service("DetectorStore")};
    if (!detStore) {
      return false;
    }
    
    const HGTD_ID* hgtdIdHelper = nullptr;
    if (detStore->retrieve(hgtdIdHelper, "HGTD_ID").isFailure()) {
      return false;
    }
    m_hgtdIdHelper = hgtdIdHelper;
  }
  
  std::cout << "Dumping Surfaces for HGTD with size = " << surfaces.size() << std::endl;
  for (auto & surface : surfaces) {
    Identifier hitId = (surface.object)->associatedDetectorElementIdentifier(); 
    std::cout <<  "barrel_ec " << m_hgtdIdHelper.load()->endcap(hitId) << ", layer_disk " << m_hgtdIdHelper.load()->layer(hitId) << ", phi_module " << m_hgtdIdHelper.load()->phi_module(hitId) << ", eta_module " << m_hgtdIdHelper.load()->eta_module(hitId) << std::endl;
  }
  return true;
}

operator=()

HGTD_OverlapDescriptor & HGTD_OverlapDescriptor::operator= ( const HGTD_OverlapDescriptor & )

delete

Delete assignment.

reachableSurfaces()

bool HGTD_OverlapDescriptor::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 36 of file HGTD_OverlapDescriptor.cxx.

{
  surfaces.emplace_back(Trk::Intersection(pos, 0., true),&tsf);
  
  // add the other targets
  // use the center of this surface in (x,y) global coordinates and look for
  // adjactent ones in the binutiliy  
  
  float centerR = tsf.center().perp();
  float centerPhi = tsf.center().phi();
  
  std::vector<const Trk::Surface*> allSurfaces = {};
  
  const auto rBoundVal = std::lower_bound(m_valuesR.begin(), m_valuesR.end(), centerR);
  int rIndex = std::distance(m_valuesR.begin(), rBoundVal);
  
  for (int stepR=-m_nStepsR; stepR<=m_nStepsR; stepR++) {
    int index_r = rIndex+stepR;
    if (index_r>=0 and index_r<int(m_valuesR.size()-1)) {
      const auto phiBoundVal = std::lower_bound(m_valuesPhi.at(index_r).begin(), m_valuesPhi.at(index_r).end(), centerPhi);
      int phiIndex = std::distance(m_valuesPhi.at(index_r).begin(), phiBoundVal);
      for (int stepPhi=-m_nStepsPhi; stepPhi<=m_nStepsPhi; stepPhi++) {
        int index_phi = phiIndex+stepPhi;
        if (index_phi<0)
          index_phi = int(m_valuesPhi.at(index_r).size())+index_phi;
        else if (index_phi>int(m_valuesPhi.at(index_r).size()-1))
          index_phi = index_phi-int(m_valuesPhi.at(index_r).size());
        float pos_r = 0.5*(m_valuesR.at(index_r)+m_valuesR.at(index_r+1));
        float pos_phi = 0.;
        if (index_phi == int(m_valuesPhi.at(index_r).size()-1))
          pos_phi = 0.5*(m_valuesPhi.at(index_r).at(index_phi)+M_PI);
        else
          pos_phi = 0.5*(m_valuesPhi.at(index_r).at(index_phi)+m_valuesPhi.at(index_r).at(index_phi+1));          
        const Trk::Surface* surf = m_binnedArray->object(Amg::Vector2D(pos_r, pos_phi));
        if (surf and std::find(allSurfaces.begin(), allSurfaces.end(), surf) == allSurfaces.end()) {
          allSurfaces.push_back(surf);
        }
      }
    }
  }
  
  for (auto& surface : allSurfaces)
    surfaces.emplace_back(Trk::Intersection(Amg::Vector3D(0.,0.,0.),0.,true),surface);
  
  return false;
}

Member Data Documentation

m_binnedArray

const Trk::BinnedArray<Trk::Surface>* HGTD_OverlapDescriptor::m_binnedArray

private

Definition at line 74 of file HGTD_OverlapDescriptor.h.

m_hgtdIdHelper

std::atomic<const HGTD_ID*> HGTD_OverlapDescriptor::m_hgtdIdHelper {nullptr}

mutableprivate

Definition at line 79 of file HGTD_OverlapDescriptor.h.

{nullptr};

m_nStepsPhi

int HGTD_OverlapDescriptor::m_nStepsPhi

private

Definition at line 78 of file HGTD_OverlapDescriptor.h.

m_nStepsR

int HGTD_OverlapDescriptor::m_nStepsR

private

Definition at line 77 of file HGTD_OverlapDescriptor.h.

m_valuesPhi

std::vector< std::vector< float> > HGTD_OverlapDescriptor::m_valuesPhi

private

Definition at line 76 of file HGTD_OverlapDescriptor.h.

m_valuesR

std::vector< float > HGTD_OverlapDescriptor::m_valuesR

private

Definition at line 75 of file HGTD_OverlapDescriptor.h.

---

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

• HGTD_OverlapDescriptor.h
• HGTD_OverlapDescriptor.cxx