DigitizationModule.hpp

Go to the documentation of this file. Or view the newest version in sPHENIX GitHub for file DigitizationModule.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/Definitions/Algebra.hpp"
#include "Acts/Digitization/DigitizationCell.hpp"
#include "Acts/Digitization/Segmentation.hpp"

#include <memory>
#include <vector>

namespace Acts {

class Surface;

using SurfacePtr = std::shared_ptr<const Surface>;
using SurfacePtrVector = std::vector<SurfacePtr>;

class DigitizationModule {
 public:
  DigitizationModule(std::shared_ptr<const Segmentation> moduleSegmentation,
                     double halfThickness, int readoutDirection,
                     double lorentzAngle, double energyThreshold = 0.,
                     bool analogue = false);

  virtual ~DigitizationModule() = default;

  const SurfacePtrVector segmentationSurfaces(
      const DigitizationCell& entryCids,
      const DigitizationCell& exitCids) const;

  const DigitizationCell cell(const Vector2& position) const;

  double halfThickness() const;

  int readoutDirection() const;

  double lorentzAngle() const;

  double energyThreshold() const;

  bool analogue() const;

  const Segmentation& segmentation() const;

  SurfacePtrVector stepSurfaces(const Vector3& start, const Vector3& end) const;

  DigitizationStep digitizationStep(const Vector3& start,
                                    const Vector3& end) const;

  const SurfacePtrVector& boundarySurfaces() const;

  const SurfacePtrVector& segmentationSurfacesX() const;

  const SurfacePtrVector& segmentationSurfacesY() const;

 private:
  double m_halfThickness;
  int m_readoutDirection;
  double m_lorentzAngle;
  double m_tanLorentzAngle;
  double m_energyThreshold;
  bool m_analogue;
  std::shared_ptr<const Segmentation> m_segmentation;
  SurfacePtrVector m_boundarySurfaces;
  SurfacePtrVector m_segmentationSurfacesX;
  SurfacePtrVector m_segmentationSurfacesY;
};

inline double DigitizationModule::halfThickness() const {
  return m_halfThickness;
}

inline int DigitizationModule::readoutDirection() const {
  return m_readoutDirection;
}

inline double DigitizationModule::lorentzAngle() const {
  return m_lorentzAngle;
}

inline double DigitizationModule::energyThreshold() const {
  return m_energyThreshold;
}

inline bool DigitizationModule::analogue() const {
  return m_analogue;
}

inline const Segmentation& DigitizationModule::segmentation() const {
  return (*(m_segmentation.get()));
}

inline const SurfacePtrVector& DigitizationModule::boundarySurfaces() const {
  return m_boundarySurfaces;
}

inline const SurfacePtrVector& DigitizationModule::segmentationSurfacesX()
    const {
  return m_segmentationSurfacesX;
}

inline const SurfacePtrVector& DigitizationModule::segmentationSurfacesY()
    const {
  return m_segmentationSurfacesY;
}

inline DigitizationStep DigitizationModule::digitizationStep(
    const Vector3& start, const Vector3& end) const {
  return m_segmentation->digitizationStep(start, end, m_halfThickness,
                                          m_readoutDirection, m_lorentzAngle);
}
}  // namespace Acts