MaterialMapJsonConverter.hpp

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

// This file is part of the Acts project.
//
// Copyright (C) 2017-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/Geometry/GeometryContext.hpp"
#include "Acts/Geometry/GeometryIdentifier.hpp"
#include "Acts/Geometry/TrackingGeometry.hpp"
#include "Acts/Material/ISurfaceMaterial.hpp"
#include "Acts/Material/IVolumeMaterial.hpp"
#include "Acts/Plugins/Json/ActsJson.hpp"
#include "Acts/Plugins/Json/GeometryHierarchyMapJsonConverter.hpp"
#include "Acts/Plugins/Json/ITrackingGeometryJsonDecorator.hpp"
#include "Acts/Plugins/Json/IVolumeMaterialJsonDecorator.hpp"
#include "Acts/Utilities/Logger.hpp"
#include <Acts/Geometry/TrackingVolume.hpp>
#include <Acts/Surfaces/Surface.hpp>

#include <map>
#include <memory>
#include <string>
#include <tuple>
#include <utility>
#include <vector>

#include <nlohmann/json.hpp>

namespace Acts {
class ISurfaceMaterial;
class ITrackingGeometryJsonDecorator;
class IVolumeMaterial;
class IVolumeMaterialJsonDecorator;
class Surface;
class TrackingGeometry;
class TrackingVolume;

using SurfaceAndMaterialWithContext =
    std::tuple<std::shared_ptr<const Acts::Surface>,
               std::shared_ptr<const Acts::ISurfaceMaterial>,
               Acts::GeometryContext>;
using TrackingVolumeAndMaterial =
    std::pair<const Acts::TrackingVolume*,
              std::shared_ptr<const Acts::IVolumeMaterial>>;

class MaterialMapJsonConverter {
 public:
  using SurfaceMaterialMap =
      std::map<GeometryIdentifier, std::shared_ptr<const ISurfaceMaterial>>;
  using VolumeMaterialMap =
      std::map<GeometryIdentifier, std::shared_ptr<const IVolumeMaterial>>;
  using DetectorMaterialMaps = std::pair<SurfaceMaterialMap, VolumeMaterialMap>;

  class Config {
   public:
    GeometryContext context = GeometryContext();

    bool processSensitives = true;
    bool processApproaches = true;
    bool processRepresenting = true;
    bool processBoundaries = true;
    bool processVolumes = true;
    bool processDenseVolumes = false;
    bool processNonMaterial = false;
  };

  MaterialMapJsonConverter(const Config& config, Acts::Logging::Level level);

  ~MaterialMapJsonConverter() = default;

  DetectorMaterialMaps jsonToMaterialMaps(const nlohmann::json& materialmaps);

  nlohmann::json materialMapsToJson(
      const DetectorMaterialMaps& maps,
      const IVolumeMaterialJsonDecorator* decorator = nullptr);

  nlohmann::json trackingGeometryToJson(
      const TrackingGeometry& tGeometry,
      const ITrackingGeometryJsonDecorator* decorator = nullptr);

  void convertToHierarchy(
      std::vector<std::pair<GeometryIdentifier,
                            Acts::TrackingVolumeAndMaterial>>& volumeHierarchy,
      std::vector<
          std::pair<GeometryIdentifier, Acts::SurfaceAndMaterialWithContext>>&
          surfaceHierarchy,
      const Acts::TrackingVolume* tVolume);

 private:
  Config m_cfg;

  std::unique_ptr<const Logger> m_logger{nullptr};

  std::string m_volumeName = "Material Volume Map";
  Acts::GeometryHierarchyMapJsonConverter<const IVolumeMaterial*,
                                          Acts::IVolumeMaterialJsonDecorator>
      m_volumeMaterialConverter;
  Acts::GeometryHierarchyMapJsonConverter<Acts::TrackingVolumeAndMaterial,
                                          Acts::ITrackingGeometryJsonDecorator>
      m_volumeConverter;

  std::string m_surfaceName = "Material Surface Map";
  Acts::GeometryHierarchyMapJsonConverter<const ISurfaceMaterial*,
                                          Acts::IVolumeMaterialJsonDecorator>
      m_surfaceMaterialConverter;
  Acts::GeometryHierarchyMapJsonConverter<Acts::SurfaceAndMaterialWithContext,
                                          Acts::ITrackingGeometryJsonDecorator>
      m_surfaceConverter;

  const Logger& logger() const { return *m_logger; }
};

}  // namespace Acts