Intersection.hpp

Go to the documentation of this file. Or view the newest version in sPHENIX GitHub for file Intersection.hpp

// This file is part of the Acts project.
//
// Copyright (C) 2016-2018 CERN for the benefit of the Acts project
//
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at http://mozilla.org/MPL/2.0/.

// Intersection.hpp, Acts project

#pragma once
#include <limits>

#include "Definitions.hpp"

namespace Acts {

template <unsigned int DIM>
struct Intersection {
  enum class Status : int {
    missed = 0,
    unreachable = 0,
    reachable = 1,
    onSurface = 2
  };

  ActsVector<double, DIM> position = ActsVector<double, DIM>::Zero();
  double pathLength{std::numeric_limits<double>::infinity()};
  Status status{Status::unreachable};

  Intersection(const ActsVector<double, DIM>& sinter, double slength,
               Status sstatus)
      : position(sinter), pathLength(slength), status(sstatus) {}

  Intersection() = default;

  explicit operator bool() const { return (status != Status::missed); }

  bool operator<(const Intersection<DIM>& si) const {
    if (status == Status::unreachable) {
      return false;
    }
    // Now check the pathLength
    if (si.status != Status::unreachable) {
      return (pathLength < si.pathLength);
    }
    // The current one wins, no re-ordering
    return true;
  }

  bool operator>(const Intersection<DIM>& si) const {
    if (status == Status::unreachable) {
      return false;
    }
    // Now check the pathLength
    if (si.status != Status::unreachable) {
      return (pathLength > si.pathLength);
    }
    // The current one wins, no re-ordering
    return true;
  }
};

using Intersection2D = Intersection<2>;

using Intersection3D = Intersection<3>;

template <typename object_t, typename representation_t = object_t>
class ObjectIntersection {
 public:
  Intersection3D intersection{};
  const object_t* object{nullptr};
  const representation_t* representation{nullptr};

  Intersection3D alternative{};

  ObjectIntersection() = default;

  template <typename T = representation_t,
            std::enable_if_t<std::is_same<T, object_t>::value, int> = 0>
  ObjectIntersection(const Intersection3D& sInter, const object_t* sObject)
      : intersection(sInter), object(sObject), representation(sObject) {}

  ObjectIntersection(const Intersection3D& sInter, const object_t* sObject,
                     const representation_t* sRepresentation)
      : intersection(sInter),
        object(sObject),
        representation(sRepresentation) {}

  explicit operator bool() const { return bool(intersection); }

  bool operator<(
      const ObjectIntersection<object_t, representation_t>& oi) const {
    return (intersection < oi.intersection);
  }

  bool operator>(
      const ObjectIntersection<object_t, representation_t>& oi) const {
    return (intersection > oi.intersection);
  }
};

struct SameSurfaceIntersection {
  template <typename intersection_t>
  bool operator()(const intersection_t& i1, const intersection_t& i2) const {
    return (i1.object == i2.object);
  }
};

}  // namespace Acts