Blueprint.hpp

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

// This file is part of the Acts project.
//
// Copyright (C) 2023 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/Common.hpp"
#include "Acts/Geometry/VolumeBounds.hpp"
#include "Acts/Utilities/BinningData.hpp"

#include <memory>
#include <string>
#include <vector>

namespace Acts {
namespace Experimental {

class IGeometryIdGenerator;
class IInternalStructureBuilder;
class IRootVolumeFinderBuilder;

namespace Blueprint {

struct Node final {
  Node(const std::string& n, const Transform3& t, VolumeBounds::BoundsType bt,
       const std::vector<ActsScalar>& bv, const std::vector<BinningValue>& bss,
       std::vector<std::unique_ptr<Node>> cs = {})
      : name(n),
        transform(t),
        boundsType(bt),
        boundaryValues(bv),
        children(std::move(cs)),
        binning(bss) {
    for_each(children.begin(), children.end(),
             [this](std::unique_ptr<Node>& c) { c->parent = this; });
  }

  Node(const std::string& n, const Transform3& t, VolumeBounds::BoundsType bt,
       const std::vector<ActsScalar>& bv,
       std::shared_ptr<const IInternalStructureBuilder> isb = nullptr)
      : name(n),
        transform(t),
        boundsType(bt),
        boundaryValues(bv),
        internalsBuilder(std::move(isb)) {}

  std::string name = "";
  Transform3 transform = Transform3::Identity();
  VolumeBounds::BoundsType boundsType = VolumeBounds::eOther;
  std::vector<ActsScalar> boundaryValues = {};
  const Node* parent = nullptr;
  std::vector<std::unique_ptr<Node>> children = {};
  std::vector<BinningValue> binning = {};

  std::shared_ptr<const IRootVolumeFinderBuilder> rootVolumeFinderBuilder =
      nullptr;
  std::shared_ptr<const IGeometryIdGenerator> geoIdGenerator = nullptr;
  std::shared_ptr<const IInternalStructureBuilder> internalsBuilder = nullptr;

  bool isLeaf() const { return children.empty(); }

  bool isRoot() const { return parent == nullptr; }

  void add(std::unique_ptr<Node> c) {
    c->parent = this;
    children.push_back(std::move(c));
  }

  template <typename stream_type>
  void dotStream(stream_type& ss,
                 const std::string& graphName = "blueprint") const {
    if (isRoot()) {
      ss << "digraph " << graphName << " {" << '\n';
      ss << name
         << " [shape=\"circle\";style=\"filled\";fillcolor=\"darkorange\"];"
         << '\n';

    } else if (isLeaf()) {
      std::string color =
          (internalsBuilder != nullptr) ? "darkolivegreen1" : "darkolivegreen3";

      ss << name << " [shape=\"box\";style=\"filled\";fillcolor=\"";
      ss << color << "\"];" << '\n';
    } else {
      ss << name << " [shape=\"diamond\"];" << '\n';
    }

    ss << name << " [label=\"" << name << "\"];" << '\n';
    for (const auto& c : children) {
      ss << name << " -> " << c->name << ";" << '\n';
      c->dotStream(ss);
    }
    if (children.empty()) {
      ss << name + "_shape"
         << " [shape=\"cylinder\";style=\"filled\";fillcolor=\"lightgrey\"];"
         << '\n';
      ss << name << " -> " << name + "_shape"
         << ";" << '\n';
    }

    if (internalsBuilder != nullptr) {
      ss << name + "_int"
         << " [shape=\"doubleoctagon\";style=\"filled\";fillcolor="
            "\"cadetblue1\"];"
         << '\n';
      ss << name << " -> " << name + "_int"
         << ";" << '\n';
    }

    if (geoIdGenerator != nullptr) {
      ss << name + "_geoID"
         << " [shape=\"note\";style=\"filled\";fillcolor=\"azure\"];" << '\n';
      ss << name << " -> " << name + "_geoID"
         << ";" << '\n';
    }

    if (rootVolumeFinderBuilder != nullptr) {
      ss << name + "_roots"
         << " [shape=\"Msquare\";style=\"filled\";fillcolor=\"darkkhaki\"];"
         << '\n';
      ss << name << " -> " << name + "_roots"
         << ";" << '\n';
    }

    if (isRoot()) {
      ss << "}" << '\n';
    }
  }
};

}  // namespace Blueprint
}  // namespace Experimental
}  // namespace Acts