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 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 <functional>
#include <memory>
#include <vector>
#include "Acts/Geometry/GeometryContext.hpp"
#include "Acts/Geometry/ITrackingVolumeBuilder.hpp"
#include "Acts/Utilities/BinningType.hpp"
#include "Acts/Utilities/Definitions.hpp"

namespace Acts {

class TrackingVolume;
class VolumeBounds;
class RectangleBounds;
class ISurfaceMaterial;
class IVolumeMaterial;
class DetectorElementBase;
class PlaneSurface;

class CuboidVolumeBuilder : public ITrackingVolumeBuilder {
 public:
  struct SurfaceConfig {
    // Center position
    Vector3D position;
    // Rotation
    RotationMatrix3D rotation = RotationMatrix3D::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*(std::shared_ptr<const Transform3D>,
                                       std::shared_ptr<const RectangleBounds>,
                                       double)>
        detElementConstructor;
  };

  struct LayerConfig {
    // Configuration of the surface
    SurfaceConfig surfaceCfg;
    // Encapsulated surface
    std::shared_ptr<const PlaneSurface> surface = nullptr;
    // 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;
  };

  struct VolumeConfig {
    // Center position
    Vector3D position;
    // Lengths in x,y,z
    Vector3D 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
    Vector3D position = Vector3D(0., 0., 0.);
    // Length in x,y,z
    Vector3D length = Vector3D(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 PlaneSurface> 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, Vector3D>>& tapVec,
                   BinningValue bValue) const;

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

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