CuboidVolumeBuilder.hpp

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

// This file is part of the Acts project.
//
// Copyright (C) 2018-2020 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/Geometry/GeometryContext.hpp"
#include "Acts/Geometry/ITrackingVolumeBuilder.hpp"
#include "Acts/Utilities/BinningType.hpp"

#include <array>
#include <cstddef>
#include <functional>
#include <iosfwd>
#include <memory>
#include <optional>
#include <string>
#include <utility>
#include <vector>

namespace Acts {

class TrackingVolume;
class VolumeBounds;
class RectangleBounds;
class ISurfaceMaterial;
class IVolumeMaterial;
class DetectorElementBase;
class Surface;
class Layer;

class CuboidVolumeBuilder : public ITrackingVolumeBuilder {
 public:
  struct SurfaceConfig {
    // Center position
    Vector3 position;
    // Rotation
    RotationMatrix3 rotation = RotationMatrix3::Identity();
    // Bounds
    std::shared_ptr<const RectangleBounds> rBounds = nullptr;
    // Attached material
    std::shared_ptr<const ISurfaceMaterial> surMat = nullptr;
    // Thickness
    double thickness = 0.;
    // Constructor function for optional detector elements
    // Arguments are transform, rectangle bounds and thickness.
    std::function<DetectorElementBase*(
        const Transform3&, std::shared_ptr<const RectangleBounds>, double)>
        detElementConstructor;
  };

  struct LayerConfig {
    // Configuration of the surface
    std::vector<SurfaceConfig> surfaceCfg;
    // Encapsulated surface
    std::vector<std::shared_ptr<const Surface>> surfaces;
    // Boolean flag if layer is active
    bool active = false;
    // Bins in Y direction
    size_t binsY = 1;
    // Bins in Z direction
    size_t binsZ = 1;
    // Envelope in X
    std::array<ActsScalar, 2u> envelopeX{0, 0};
    // Envelope in Y
    std::array<ActsScalar, 2u> envelopeY{0, 0};
    // Envelope in Z
    std::array<ActsScalar, 2u> envelopeZ{0, 0};
    // An optional rotation for this
    std::optional<RotationMatrix3> rotation{std::nullopt};
  };

  struct VolumeConfig {
    // Center position
    Vector3 position;
    // Lengths in x,y,z
    Vector3 length;
    // Configurations of its layers
    std::vector<LayerConfig> layerCfg;
    // Stored layers
    std::vector<std::shared_ptr<const Layer>> layers;
    // Configurations of confined volumes
    std::vector<VolumeConfig> volumeCfg;
    // Stored confined volumes
    std::vector<std::shared_ptr<TrackingVolume>> trackingVolumes;
    // Name of the volume
    std::string name = "Volume";
    // Material
    std::shared_ptr<const IVolumeMaterial> volumeMaterial = nullptr;
  };

  struct Config {
    // Center position
    Vector3 position = Vector3(0., 0., 0.);
    // Length in x,y,z
    Vector3 length = Vector3(0., 0., 0.);
    // Configuration of its volumes
    std::vector<VolumeConfig> volumeCfg = {};
  };

  CuboidVolumeBuilder() = default;

  CuboidVolumeBuilder(Config& cfg) : m_cfg(cfg) {}

  void setConfig(Config& cfg) { m_cfg = cfg; }

  std::shared_ptr<const Surface> buildSurface(const GeometryContext& gctx,
                                              const SurfaceConfig& cfg) const;

  std::shared_ptr<const Layer> buildLayer(const GeometryContext& gctx,
                                          LayerConfig& cfg) const;

  std::shared_ptr<TrackingVolume> buildVolume(const GeometryContext& gctx,
                                              VolumeConfig& cfg) const;

  std::pair<double, double> binningRange(const GeometryContext& gctx,
                                         const VolumeConfig& cfg) const;

  void sortVolumes(std::vector<std::pair<TrackingVolumePtr, Vector3>>& tapVec,
                   BinningValue bValue) const;

  std::shared_ptr<TrackingVolume> trackingVolume(
      const GeometryContext& gctx,
      std::shared_ptr<const TrackingVolume> /*oppositeVolume*/,
      std::shared_ptr<const VolumeBounds> /*outsideBounds*/) const override;

 private:
  Config m_cfg;
};
}  // namespace Acts