TGeoLayerBuilder.hpp

Go to the documentation of this file. Or view the newest version in sPHENIX GitHub for file TGeoLayerBuilder.hpp

// This file is part of the Acts project.
//
// Copyright (C) 2017-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/Definitions/Units.hpp"
#include "Acts/Geometry/GeometryContext.hpp"
#include "Acts/Geometry/ILayerBuilder.hpp"
#include "Acts/Geometry/LayerCreator.hpp"
#include "Acts/Geometry/ProtoLayerHelper.hpp"
#include "Acts/Geometry/SurfaceBinningMatcher.hpp"
#include "Acts/Plugins/Identification/Identifier.hpp"
#include "Acts/Plugins/TGeo/ITGeoIdentifierProvider.hpp"
#include "Acts/Utilities/BinningType.hpp"
#include "Acts/Utilities/Logger.hpp"

#include <algorithm>
#include <array>
#include <climits>
#include <functional>
#include <memory>
#include <string>
#include <tuple>
#include <utility>
#include <vector>

class TGeoMatrix;
class TGeoVolume;
class TGeoNode;

namespace Acts {

class TGeoDetectorElement;
class ITGeoDetectorElementSplitter;
class Surface;
class ISurfaceMaterial;
class ITGeoIdentifierProvider;
class LayerCreator;
class ProtoLayerHelper;

class TGeoLayerBuilder : public ILayerBuilder {
 public:
  struct LayerConfig {
   public:
    using RangeConfig = std::pair<BinningValue, std::pair<double, double>>;

    using SplitConfig = std::pair<BinningValue, double>;

    std::string volumeName = "";
    std::vector<std::string> sensorNames = {};
    std::string localAxes = "XYZ";
    std::vector<RangeConfig> parseRanges = {};
    std::vector<SplitConfig> splitConfigs = {};
    std::pair<double, double> envelope = {1 * UnitConstants::mm,
                                          1 * UnitConstants::mm};
    std::vector<std::pair<int, BinningType>> binning0 = {{-1, equidistant}};
    std::vector<std::pair<int, BinningType>> binning1 = {{-1, equidistant}};

    // Default constructor
    LayerConfig()
        : volumeName(""),
          sensorNames({}),
          localAxes("XZY"),
          envelope(std::pair<double, double>(1 * UnitConstants::mm,
                                             1 * UnitConstants::mm)) {}
  };

  using ElementFactory = std::function<std::shared_ptr<TGeoDetectorElement>(
      const Identifier&, const TGeoNode&, const TGeoMatrix& tGeoMatrix,
      const std::string& axes, double scalor,
      std::shared_ptr<const Acts::ISurfaceMaterial> material)>;

  static std::shared_ptr<TGeoDetectorElement> defaultElementFactory(
      const Identifier& identifier, const TGeoNode& tGeoNode,
      const TGeoMatrix& tGeoMatrix, const std::string& axes, double scalor,
      std::shared_ptr<const Acts::ISurfaceMaterial> material);

  struct Config {
    std::string configurationName = "undefined";
    double unit = 1 * UnitConstants::cm;
    std::shared_ptr<const ITGeoIdentifierProvider> identifierProvider = nullptr;
    std::shared_ptr<const ITGeoDetectorElementSplitter>
        detectorElementSplitter = nullptr;
    ElementFactory elementFactory = defaultElementFactory;
    std::shared_ptr<const LayerCreator> layerCreator = nullptr;
    std::shared_ptr<const ProtoLayerHelper> protoLayerHelper = nullptr;
    std::array<std::vector<LayerConfig>, 3> layerConfigurations;
    std::array<double, 3> layerSplitToleranceR = {-1., -1., -1.};
    std::array<double, 3> layerSplitToleranceZ = {-1., -1., -1.};
    bool autoSurfaceBinning = false;
    Acts::SurfaceBinningMatcher surfaceBinMatcher;
  };

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

  ~TGeoLayerBuilder() override;

  const LayerVector negativeLayers(const GeometryContext& gctx) const final;

  const LayerVector centralLayers(const GeometryContext& gctx) const final;

  const LayerVector positiveLayers(const GeometryContext& gctx) const final;

  const std::string& identification() const final;

  void setConfiguration(const Config& config);

  Config getConfiguration() const;

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

  const std::vector<std::shared_ptr<const TGeoDetectorElement>>&
  detectorElements() const;

 private:
  Config m_cfg;

  std::array<std::string, 3> m_layerTypes = {"Negative", "Central", "Positive"};

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

  std::unique_ptr<const Logger> m_logger;

  std::vector<std::shared_ptr<const TGeoDetectorElement>> m_elementStore;

  void buildLayers(const GeometryContext& gctx, LayerVector& layers,
                   int type = 0);

  void registerSplit(std::vector<double>& parameters, double test,
                     double tolerance, std::pair<double, double>& range) const;
};

inline void TGeoLayerBuilder::registerSplit(
    std::vector<double>& parameters, double test, double tolerance,
    std::pair<double, double>& range) const {
  bool found = false;
  // min/max setting
  range.first = std::min(range.first, test);
  range.second = std::max(range.second, test);
  // Loop and find the split parameters
  for (auto& splitPar : parameters) {
    if (std::abs(test - splitPar) < tolerance) {
      found = true;
    }
  }
  if (not found) {
    parameters.push_back(test);
  }
}

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

inline const std::vector<std::shared_ptr<const TGeoDetectorElement>>&
TGeoLayerBuilder::detectorElements() const {
  return m_elementStore;
}

inline const std::string& TGeoLayerBuilder::identification() const {
  return m_cfg.configurationName;
}

}  // namespace Acts