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

// TGeoLayerBuilder.h, Acts project, TGeoDetector plugin

#pragma once
#include <climits>
#include "Acts/Geometry/GeometryContext.hpp"
#include "Acts/Geometry/ILayerBuilder.hpp"
#include "Acts/Geometry/LayerCreator.hpp"
#include "Acts/Plugins/TGeo/ITGeoIdentifierProvider.hpp"
#include "Acts/Utilities/Definitions.hpp"
#include "Acts/Utilities/Logger.hpp"
#include "Acts/Utilities/Units.hpp"

class TGeoMatrix;
class TGeoVolume;
class TGeoNode;

namespace Acts {

class TGeoDetectorElement;
class Surface;

using NodeTransform = std::pair<TGeoNode*, std::shared_ptr<const Transform3D>>;
using namespace Acts::UnitLiterals;

class TGeoLayerBuilder : public ILayerBuilder {
 public:
  struct LayerConfig {
   public:
    std::string layerName = "";
    std::string sensorName = "";
    std::string localAxes = "xyz";
    std::pair<double, double> parseRangeR = {
        0., std::numeric_limits<double>::max()};
    std::pair<double, double> parseRangeZ = {
        -std::numeric_limits<double>::max(),
        std::numeric_limits<double>::max()};
    std::pair<double, double> envelope = {0_mm, 0_mm};
    std::pair<double, double> splitRangeR = {
        std::numeric_limits<double>::max(),
        -std::numeric_limits<double>::max()};
    std::vector<double> splitParametersR = {};
    std::pair<double, double> splitRangeZ = {
        std::numeric_limits<double>::max(),
        -std::numeric_limits<double>::max()};
    std::vector<double> splitParametersZ = {};
    size_t binsLoc0{1};
    size_t binsLoc1{1};

    // Default constructor
    LayerConfig()
        : layerName(""),
          sensorName(""),
          localAxes("XZY"),
          envelope(std::pair<double, double>(1_mm, 1_mm)) {}
  };

  struct Config {
    std::string configurationName = "undefined";
    double unit = 1_cm;
    std::shared_ptr<const ITGeoIdentifierProvider> identifierProvider = nullptr;
    std::shared_ptr<const LayerCreator> layerCreator = 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 checkRingLayout = false;
    double ringTolerance = 0_mm;
  };

  TGeoLayerBuilder(const Config& config,
                   std::unique_ptr<const Logger> logger =
                       getDefaultLogger("LayerArrayCreator", 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 resolveSensitive(
      const GeometryContext& gctx,
      std::vector<std::shared_ptr<const Surface>>& layerSurfaces,
      TGeoVolume* tgVolume, TGeoNode* tgNode, const TGeoMatrix& tgTransform,
      LayerConfig& layerConfig, int type, bool correctBranch = false,
      const std::string& offset = "");

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

  bool match(const char* first, const char* second) const;

  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;
}

// The main function that checks if two given strings
// match. The first string may contain wildcard characters
inline bool TGeoLayerBuilder::match(const char* first,
                                    const char* second) const {
  // If we reach at the end of both strings, we are done
  if (*first == '\0' && *second == '\0') {
    return true;
  }

  // Make sure that the characters after '*' are present
  // in second string. This function assumes that the first
  // string will not contain two consecutive '*'
  if (*first == '*' && *(first + 1) != '\0' && *second == '\0') {
    return false;
  }

  // If the first string contains '?', or current characters
  // of both strings match
  if (*first == '?' || *first == *second) {
    return match(first + 1, second + 1);
  }

  // If there is *, then there are two possibilities
  // a) We consider current character of second string
  // b) We ignore current character of second string.
  if (*first == '*') {
    return match(first + 1, second) || match(first, second + 1);
  }
  return false;
}
}  // namespace Acts