ProtoDetector.hpp

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

// This file is part of the Acts project.
//
// Copyright (C) 2022 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/Geometry/Extent.hpp"
#include "Acts/Geometry/GeometryContext.hpp"
#include "Acts/Surfaces/Surface.hpp"
#include "Acts/Utilities/BinningData.hpp"
#include "Acts/Utilities/BinningType.hpp"
#include "Acts/Utilities/Logger.hpp"

#include <functional>
#include <map>
#include <memory>
#include <optional>
#include <string>
#include <tuple>
#include <vector>

namespace Acts {

struct ProtoVolume;

namespace Experimental {

class DetectorVolume;
class Portal;

using DetectorVolumes = std::vector<std::shared_ptr<DetectorVolume>>;
using ProtoContainer = std::map<unsigned int, std::shared_ptr<Portal>>;
using DetectorBlock = std::tuple<DetectorVolumes, ProtoContainer>;

using DetectorBlockBuilder = std::function<void(
    DetectorBlock&, const GeometryContext&, Acts::Logging::Level)>;
}  // namespace Experimental

struct ProtoVolume {
  // Internal structure information
  struct InternalStructure {
    Surface::SurfaceType layerType = Surface::SurfaceType::Other;
    std::vector<BinningData> surfaceBinning = {};
  };

  // Container structure information
  struct ContainerStructure {
    std::vector<ProtoVolume> constituentVolumes = {};
    std::vector<BinningData> constituentBinning = {};
    bool layerContainer = false;
  };

  std::string name = "";
  Extent extent;

  std::optional<InternalStructure> internal = std::nullopt;

  std::optional<ContainerStructure> container = std::nullopt;

  Experimental::DetectorBlockBuilder blockBuilder;

  bool operator==(const ProtoVolume& ptVolume) const;

  void harmonize(bool legacy = true);

  void extendUp(ProtoVolume& ptVolume);

  void propagateMinDown(BinningValue bValue);

  void propagateMaxDown(BinningValue bValue);

  void constrainDown(const ProtoVolume& ptVolume);

  std::string toString(const std::string& indent = "") const;
};

struct ProtoDetector {
  std::string name = "";
  ProtoVolume worldVolume;

  void harmonize(bool legacy = true) {
    worldVolume.extendUp(worldVolume);
    worldVolume.constrainDown(worldVolume);
    worldVolume.harmonize(legacy);
  }

  std::string toString(const std::string& indent = "") const;
};

}  // namespace Acts