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/.

// BoundarySurfaceT.h, Acts project

#pragma once
#include <memory>
#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"

namespace Acts {

class Surface;


template <class T>
class BoundarySurfaceT {
  friend T;

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

 public:
  BoundarySurfaceT()
      : m_surface(nullptr),
        m_insideVolume(nullptr),
        m_outsideVolume(nullptr),
        m_insideVolumeArray(nullptr),
        m_outsideVolumeArray(nullptr) {}

  BoundarySurfaceT(std::shared_ptr<const Surface> surface, const T* inside,
                   const T* outside)
      : m_surface(std::move(surface)),
        m_insideVolume(inside),
        m_outsideVolume(outside),
        m_insideVolumeArray(nullptr),
        m_outsideVolumeArray(nullptr) {}

  BoundarySurfaceT(std::shared_ptr<const Surface> surface, VolumePtr inside,
                   VolumePtr outside)
      : m_surface(std::move(surface)),
        m_insideVolume(inside.get()),
        m_outsideVolume(outside.get()),
        m_insideVolumeArray(nullptr),
        m_outsideVolumeArray(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_insideVolume(nullptr),
        m_outsideVolume(nullptr),
        m_insideVolumeArray(insideArray),
        m_outsideVolumeArray(outsideArray) {}

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

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

  virtual const Surface& surfaceRepresentation() const;

  virtual ~BoundarySurfaceT() = default;

  void attachVolume(const T* volume, BoundaryOrientation inout);

  void attachVolumeArray(std::shared_ptr<const VolumeArray> volumes,
                         BoundaryOrientation inout);

 protected:
  std::shared_ptr<const Surface> m_surface;
  const T* m_insideVolume;
  const T* m_outsideVolume;
  std::shared_ptr<const VolumeArray> m_insideVolumeArray;
  std::shared_ptr<const VolumeArray> m_outsideVolumeArray;
};

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

template <class T>
void BoundarySurfaceT<T>::attachVolume(const T* volume,
                                       BoundaryOrientation inout) {
  if (inout == insideVolume) {
    m_insideVolume = volume;
  } else {
    m_outsideVolume = volume;
  }
}

template <class T>
void BoundarySurfaceT<T>::attachVolumeArray(
    const std::shared_ptr<const VolumeArray> volumes,
    BoundaryOrientation inout) {
  if (inout == insideVolume) {
    m_insideVolumeArray = volumes;
  } else {
    m_outsideVolumeArray = volumes;
  }
}

template <class T>
const T* BoundarySurfaceT<T>::attachedVolume(const GeometryContext& gctx,
                                             const Vector3D& pos,
                                             const Vector3D& mom,
                                             NavigationDirection pdir) const {
  const T* attVolume = nullptr;
  // dot product with normal vector to distinguish inside/outside
  if ((surfaceRepresentation().normal(gctx, pos)).dot(pdir * mom) > 0.) {
    attVolume = m_outsideVolumeArray ? m_outsideVolumeArray->object(pos).get()
                                     : m_outsideVolume;
  } else {
    attVolume = m_insideVolumeArray ? m_insideVolumeArray->object(pos).get()
                                    : m_insideVolume;
  }
  return attVolume;
}
}  // namespace Acts