CartesianSegmentation.hpp

Go to the documentation of this file. Or view the newest version in sPHENIX GitHub for file CartesianSegmentation.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 <memory>
#include "Acts/Plugins/Digitization/DigitizationCell.hpp"
#include "Acts/Plugins/Digitization/Segmentation.hpp"
#include "Acts/Surfaces/PlanarBounds.hpp"
#include "Acts/Surfaces/RectangleBounds.hpp"
#include "Acts/Utilities/BinUtility.hpp"
#include "Acts/Utilities/Definitions.hpp"

namespace Acts {

class CartesianSegmentation : public Segmentation {
 public:
  CartesianSegmentation(const std::shared_ptr<const PlanarBounds>& mBounds,
                        size_t numCellsX, size_t numCellsY = 1);

  //  it will define the RectangleBounds if none are provided
  CartesianSegmentation(std::shared_ptr<const BinUtility> bUtility,
                        std::shared_ptr<const PlanarBounds> mBounds = nullptr);

  ~CartesianSegmentation() override;

  void createSegmentationSurfaces(SurfacePtrVector& boundarySurfaces,
                                  SurfacePtrVector& segmentationSurfacesX,
                                  SurfacePtrVector& segmentationSurfacesY,
                                  double halfThickness,
                                  int readoutDirection = 1.,
                                  double lorentzAngle = 0.) const final;

  DigitizationCell cell(const Vector3D& position) const final;

  DigitizationCell cell(const Vector2D& position) const final;

  Vector2D cellPosition(const DigitizationCell& dCell) const final;

  DigitizationStep digitizationStep(const Vector3D& startStep,
                                    const Vector3D& endStep,
                                    double halfThickness,
                                    int readoutDirection = 1,
                                    double lorentzAngle = 0.) const final;

  const PlanarBounds& moduleBounds() const final;

  const BinUtility& binUtility() const final;

  std::pair<double, double> pitch() const;

 private:
  template <class T>
  DigitizationCell cellT(const T& position) const;

  std::shared_ptr<const PlanarBounds> m_activeBounds;  
  std::shared_ptr<const BinUtility> m_binUtility;      
};

inline const PlanarBounds& CartesianSegmentation::moduleBounds() const {
  return (*(m_activeBounds.get()));
}

inline const BinUtility& CartesianSegmentation::binUtility() const {
  return (*(m_binUtility.get()));
}

template <class T>
DigitizationCell CartesianSegmentation::cellT(const T& position) const {
  return DigitizationCell(m_binUtility->bin(position, 0),
                          m_binUtility->bin(position, 1));
}

inline DigitizationCell CartesianSegmentation::cell(
    const Vector3D& position) const {
  return cellT<Vector3D>(position);
}

inline DigitizationCell CartesianSegmentation::cell(
    const Vector2D& position) const {
  return cellT<Vector2D>(position);
}

inline std::pair<double, double> CartesianSegmentation::pitch() const {
  auto boundingBox = m_activeBounds->boundingBox();
  auto values = boundingBox.values();
  double pitchX = 2. * values[0] / m_binUtility->bins(0);
  double pitchY = 2. * values[1] / m_binUtility->bins(1);
  return std::pair<double, double>(pitchX, pitchY);
}

}  // namespace Acts