LayerCreator.hpp

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

// LayerCreator.h, Acts project

#pragma once

#include "Acts/Geometry/ApproachDescriptor.hpp"
#include "Acts/Geometry/GeometryContext.hpp"
#include "Acts/Geometry/SurfaceArrayCreator.hpp"
#include "Acts/Utilities/BinUtility.hpp"
#include "Acts/Utilities/Definitions.hpp"
#include "Acts/Utilities/Logger.hpp"

#include <optional>

#ifndef ACTS_LAYERCREATOR_TAKESMALLERBIGGER
#define ACTS_LAYERCREATOR_TAKESMALLERBIGGER
#define takeSmaller(current, test) current = current < test ? current : test
#define takeBigger(current, test) current = current > test ? current : test
#define takeSmallerBigger(cSmallest, cBiggest, test) \
  takeSmaller(cSmallest, test);                      \
  takeBigger(cBiggest, test)
#endif

namespace Acts {

namespace Test {
struct LayerCreatorFixture;
}
class Surface;
class Layer;
using MutableLayerPtr = std::shared_ptr<Layer>;

class LayerCreator {
 public:
  friend Acts::Test::LayerCreatorFixture;
  struct Config {
    std::shared_ptr<const SurfaceArrayCreator> surfaceArrayCreator = nullptr;
    double cylinderZtolerance{10.};
    double cylinderPhiTolerance{0.1};
    Config() = default;
  };

  LayerCreator(const Config& lcConfig,
               std::unique_ptr<const Logger> logger =
                   getDefaultLogger("LayerCreator", Logging::INFO));

  ~LayerCreator() = default;

  MutableLayerPtr cylinderLayer(
      const GeometryContext& gctx,
      std::vector<std::shared_ptr<const Surface>> surfaces, size_t binsPhi,
      size_t binsZ, std::optional<ProtoLayer> _protoLayer = std::nullopt,
      std::shared_ptr<const Transform3D> transform = nullptr,
      std::unique_ptr<ApproachDescriptor> ad = nullptr) const;

  MutableLayerPtr cylinderLayer(
      const GeometryContext& gctx,
      std::vector<std::shared_ptr<const Surface>> surfaces,
      BinningType bTypePhi, BinningType bTypeZ,
      std::optional<ProtoLayer> _protoLayer = std::nullopt,
      std::shared_ptr<const Transform3D> transform = nullptr,
      std::unique_ptr<ApproachDescriptor> ad = nullptr) const;

  MutableLayerPtr discLayer(
      const GeometryContext& gctx,
      std::vector<std::shared_ptr<const Surface>> surfaces, size_t binsR,
      size_t binsPhi, std::optional<ProtoLayer> _protoLayer = std::nullopt,
      std::shared_ptr<const Transform3D> transform = nullptr,
      std::unique_ptr<ApproachDescriptor> ad = nullptr) const;

  MutableLayerPtr discLayer(
      const GeometryContext& gctx,
      std::vector<std::shared_ptr<const Surface>> surfaces, BinningType bTypeR,
      BinningType bTypePhi,
      std::optional<ProtoLayer> _protoLayer = std::nullopt,
      std::shared_ptr<const Transform3D> transform = nullptr,
      std::unique_ptr<ApproachDescriptor> ad = nullptr) const;

  MutableLayerPtr planeLayer(
      const GeometryContext& gctx,
      std::vector<std::shared_ptr<const Surface>> surfaces, size_t bins1,
      size_t bins2, BinningValue bValue,
      std::optional<ProtoLayer> _protoLayer = std::nullopt,
      std::shared_ptr<const Transform3D> transform = nullptr,
      std::unique_ptr<ApproachDescriptor> ad = nullptr) const;

  void setConfiguration(const Config& lcConfig);

  Config getConfiguration() const;

  void setLogger(std::unique_ptr<const Logger> newLogger);

  // associate surfaces contained by this layer to this layer
  void associateSurfacesToLayer(Layer& layer) const;

 private:
  bool checkBinning(const GeometryContext& gctx,
                    const SurfaceArray& sArray) const;

  Config m_cfg;

  const Logger& logger() const { return *m_logger; }

  std::unique_ptr<const Logger> m_logger;
};

inline LayerCreator::Config LayerCreator::getConfiguration() const {
  return m_cfg;
}

}  // namespace Acts