BoundarySurfaceT.hpp

Go to the documentation of this file. Or view the newest version in sPHENIX GitHub for file BoundarySurfaceT.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/.

#pragma once
#include "Acts/Geometry/BoundarySurfaceFace.hpp"
#include "Acts/Geometry/GeometryContext.hpp"
#include "Acts/Geometry/Volume.hpp"
#include "Acts/Utilities/BinnedArray.hpp"
#include "Acts/Utilities/Definitions.hpp"

#include <memory>

namespace Acts {

class Surface;


template <class volume_t>
class BoundarySurfaceT {
  friend volume_t;

  using VolumePtr = std::shared_ptr<const volume_t>;
  using VolumeArray = BinnedArray<VolumePtr>;

 public:
  BoundarySurfaceT()
      : m_surface(nullptr),
        m_oppositeVolume(nullptr),
        m_alongVolume(nullptr),
        m_oppositeVolumeArray(nullptr),
        m_alongVolumeArray(nullptr) {}

  BoundarySurfaceT(std::shared_ptr<const Surface> surface,
                   const volume_t* inside, const volume_t* outside)
      : m_surface(std::move(surface)),
        m_oppositeVolume(inside),
        m_alongVolume(outside),
        m_oppositeVolumeArray(nullptr),
        m_alongVolumeArray(nullptr) {}

  BoundarySurfaceT(std::shared_ptr<const Surface> surface, VolumePtr inside,
                   VolumePtr outside)
      : m_surface(std::move(surface)),
        m_oppositeVolume(inside.get()),
        m_alongVolume(outside.get()),
        m_oppositeVolumeArray(nullptr),
        m_alongVolumeArray(nullptr) {}

  BoundarySurfaceT(std::shared_ptr<const Surface> surface,
                   std::shared_ptr<const VolumeArray> insideArray,
                   std::shared_ptr<const VolumeArray> outsideArray)
      : m_surface(std::move(surface)),
        m_oppositeVolume(nullptr),
        m_alongVolume(nullptr),
        m_oppositeVolumeArray(insideArray),
        m_alongVolumeArray(outsideArray) {}

  virtual ~BoundarySurfaceT() = default;

  virtual const volume_t* attachedVolume(const GeometryContext& gctx,
                                         const Vector3D& pos,
                                         const Vector3D& mom,
                                         NavigationDirection pdir) const;

  template <class parameters_t>
  bool onBoundary(const GeometryContext& gctx, const parameters_t& pars) const {
    return surfaceRepresentation().isOnSurface(gctx, pars);
  }

  virtual const Surface& surfaceRepresentation() const;

  void attachVolume(const volume_t* volume, NavigationDirection navDir);

  void attachVolumeArray(std::shared_ptr<const VolumeArray> volumes,
                         NavigationDirection navDir);

 protected:
  std::shared_ptr<const Surface> m_surface;
  const volume_t* m_oppositeVolume;
  const volume_t* m_alongVolume;
  std::shared_ptr<const VolumeArray> m_oppositeVolumeArray;
  std::shared_ptr<const VolumeArray> m_alongVolumeArray;
};

template <class volume_t>
inline const Surface& BoundarySurfaceT<volume_t>::surfaceRepresentation()
    const {
  return (*(m_surface.get()));
}

template <class volume_t>
void BoundarySurfaceT<volume_t>::attachVolume(const volume_t* volume,
                                              NavigationDirection navDir) {
  if (navDir == backward) {
    m_oppositeVolume = volume;
  } else {
    m_alongVolume = volume;
  }
}

template <class volume_t>
void BoundarySurfaceT<volume_t>::attachVolumeArray(
    const std::shared_ptr<const VolumeArray> volumes,
    NavigationDirection navDir) {
  if (navDir == backward) {
    m_oppositeVolumeArray = volumes;
  } else {
    m_alongVolumeArray = volumes;
  }
}

template <class volume_t>
const volume_t* BoundarySurfaceT<volume_t>::attachedVolume(
    const GeometryContext& gctx, const Vector3D& pos, const Vector3D& mom,
    NavigationDirection navDir) const {
  const volume_t* attVolume = nullptr;
  // dot product with normal vector to distinguish inside/outside
  if ((surfaceRepresentation().normal(gctx, pos)).dot(navDir * mom) > 0.) {
    attVolume = m_alongVolumeArray ? m_alongVolumeArray->object(pos).get()
                                   : m_alongVolume;
  } else {
    attVolume = m_oppositeVolumeArray ? m_oppositeVolumeArray->object(pos).get()
                                      : m_oppositeVolume;
  }
  return attVolume;
}
}  // namespace Acts