GXF::LayerSort Class Reference

#include <LayerSort.h>

Collaboration diagram for GXF::LayerSort:

Public Types
typedef std::pair< const Trk::Layer *, const Trk::Layer * >	LayerPtrPair

Public Member Functions
bool	operator() (const LayerPtrPair &one, const LayerPtrPair &two) const

Detailed Description

Definition at line 11 of file LayerSort.h.

Member Typedef Documentation

LayerPtrPair

typedef std::pair<const Trk::Layer *, const Trk::Layer *> GXF::LayerSort::LayerPtrPair

Definition at line 13 of file LayerSort.h.

Member Function Documentation

operator()()

bool GXF::LayerSort::operator()	(	const LayerPtrPair &	one,
		const LayerPtrPair &	two
	)		const

Definition at line 23 of file LayerSort.cxx.

                                                                                  {
      auto castToCylinder = [](const LayerPtrPair & pair)->const Trk::CylinderSurface* {
        if (pair.first) return (const CylinderSurface *) &pair.first->surfaceRepresentation();
        else return nullptr;
      };
      auto castToDisc = [](const LayerPtrPair & pair)->const Trk::DiscSurface* {
        if (pair.second) return (const DiscSurface *) &pair.second->surfaceRepresentation();
        else return nullptr;
      };
      const CylinderSurface *cyl1 = castToCylinder(one);
      const DiscSurface *disc1  = castToDisc(one);
      const CylinderSurface *cyl2 = castToCylinder(two);
      const DiscSurface *disc2 = castToDisc(two);
 
      if (cyl1 and cyl2) {
        if (std::abs(cyl1->center().z() - cyl2->center().z()) > 1.) {
          return (std::abs(cyl1->center().z()) < std::abs(cyl2->center().z()));
        }
        return (cyl1->bounds().r() < cyl2->bounds().r());
      }
      if (disc1 and disc2) {
        const DiscBounds *discbounds1 = (const DiscBounds *) &disc1->bounds();
        const DiscBounds *discbounds2 = (const DiscBounds *) &disc2->bounds();
        if (discbounds1->rMax() < discbounds2->rMin() + 1) {
          return true;
        }
        if (discbounds1->rMin() > discbounds2->rMax() - 1) {
          return false;
        }
        return (std::abs(disc1->center().z()) < std::abs(disc2->center().z()));
      }
      
      if ((cyl1 != nullptr) && (disc2 != nullptr)) {
        const DiscBounds *discbounds = (const DiscBounds *) &disc2->bounds();
        if (cyl1->bounds().r() > discbounds->rMax() - 1) {
          return false;
        }
        if (cyl1->bounds().r() < discbounds->rMin() + 1) {
          return true;
        }
        return (std::abs(cyl1->center().z()) < std::abs(disc2->center().z()));
      }
      
      if ((disc1 == nullptr) || (cyl2 == nullptr)) {
        throw std::logic_error("Unhandled surface combination.");
      }
      
      const DiscBounds *discbounds = (const DiscBounds *) &disc1->bounds();
      
      if (cyl2->bounds().r() > discbounds->rMax() - 1) {
        return true;
      }
      
      if (cyl2->bounds().r() < discbounds->rMin() + 1) {
        return false;
      }
 
      return (std::abs(cyl2->center().z()) > std::abs(disc1->center().z()));
    }

---

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

• LayerSort.h
• LayerSort.cxx