JsonGeometryConverter.hpp

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

// This file is part of the Acts project.
//
// Copyright (C) 2017-2019 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/TrackingVolume.hpp>
#include <Acts/Surfaces/Surface.hpp>
#include "Acts/Geometry/TrackingGeometry.hpp"
#include "Acts/Material/ISurfaceMaterial.hpp"
#include "Acts/Material/IVolumeMaterial.hpp"
#include "Acts/Material/MaterialProperties.hpp"
#include "Acts/Utilities/BinUtility.hpp"
#include "Acts/Utilities/Definitions.hpp"
#include "Acts/Utilities/Logger.hpp"

#include <nlohmann/json.hpp>

#include <map>

namespace Acts {

class JsonGeometryConverter {
 public:
  using SurfaceMaterialMap =
      std::map<GeometryID, std::shared_ptr<const ISurfaceMaterial>>;

  using VolumeMaterialMap =
      std::map<GeometryID, std::shared_ptr<const IVolumeMaterial>>;

  using DetectorMaterialMaps = std::pair<SurfaceMaterialMap, VolumeMaterialMap>;

  using geo_id_value = uint64_t;

  using SurfaceMaterialRep = std::map<geo_id_value, const ISurfaceMaterial*>;
  using SurfaceRep = std::map<geo_id_value, const Surface*>;
  using VolumeMaterialRep = std::map<geo_id_value, const IVolumeMaterial*>;

  struct LayerRep {
    // the layer id
    GeometryID layerID;

    SurfaceMaterialRep sensitives;
    SurfaceRep sensitiveSurfaces;
    SurfaceMaterialRep approaches;
    SurfaceRep approacheSurfaces;
    const ISurfaceMaterial* representing = nullptr;
    const Surface* representingSurface = nullptr;

    operator bool() const {
      return (!sensitives.empty() or !approaches.empty() or
              representing != nullptr);
    }
  };

  struct VolumeRep {
    // The geometry id
    GeometryID volumeID;

    std::string volumeName;

    std::map<geo_id_value, LayerRep> layers;
    SurfaceMaterialRep boundaries;
    SurfaceRep boundarySurfaces;
    const IVolumeMaterial* material = nullptr;

    operator bool() const {
      return (!layers.empty() or !boundaries.empty() or material != nullptr);
    }
  };

  struct DetectorRep {
    std::map<geo_id_value, VolumeRep> volumes;
  };

  class Config {
   public:
    std::string geoversion = "undefined";
    std::string detkey = "detector";
    std::string volkey = "volumes";
    std::string namekey = "Name";
    std::string boukey = "boundaries";
    std::string laykey = "layers";
    std::string matkey = "material";
    std::string appkey = "approach";
    std::string senkey = "sensitive";
    std::string repkey = "representing";
    std::string bin0key = "bin0";
    std::string bin1key = "bin1";
    std::string bin2key = "bin2";
    std::string typekey = "type";
    std::string datakey = "data";
    std::string geoidkey = "Geoid";
    std::string surfacegeoidkey = "SGeoid";
    std::string mapkey = "matSurface";
    std::string surfacetypekey = "stype";
    std::string surfacepositionkey = "sposition";
    std::string surfacerangekey = "srange";
    std::shared_ptr<const Logger> logger;
    std::string name = "";

    bool processSensitives = true;
    bool processApproaches = true;
    bool processRepresenting = true;
    bool processBoundaries = true;
    bool processVolumes = true;
    bool processnonmaterial = false;
    bool writeData = true;

    Config(const std::string& lname = "JsonGeometryConverter",
           Logging::Level lvl = Logging::INFO)
        : logger(getDefaultLogger(lname, lvl)), name(lname) {}
  };

  JsonGeometryConverter(const Config& cfg);

  ~JsonGeometryConverter() = default;

  std::pair<std::map<GeometryID, std::shared_ptr<const ISurfaceMaterial>>,
            std::map<GeometryID, std::shared_ptr<const IVolumeMaterial>>>
  jsonToMaterialMaps(const nlohmann::json& materialmaps);

  nlohmann::json materialMapsToJson(const DetectorMaterialMaps& maps);

  nlohmann::json trackingGeometryToJson(const TrackingGeometry& tGeometry);

 private:
  void convertToRep(DetectorRep& detRep, const TrackingVolume& tVolume);

  LayerRep convertToRep(const Layer& tLayer);

  const ISurfaceMaterial* jsonToSurfaceMaterial(const nlohmann::json& material);

  const IVolumeMaterial* jsonToVolumeMaterial(const nlohmann::json& material);

  MaterialPropertiesMatrix jsonToMaterialMatrix(const nlohmann::json& data);

  BinUtility jsonToBinUtility(const nlohmann::json& bin);

  nlohmann::json detectorRepToJson(const DetectorRep& detRep);

  nlohmann::json surfaceMaterialToJson(const ISurfaceMaterial& sMaterial);

  nlohmann::json volumeMaterialToJson(const IVolumeMaterial& vMaterial);

  void addSurfaceToJson(nlohmann::json& sjson, const Surface* surface);

  Acts::BinUtility DefaultBin(const Acts::Surface& surface);

  Acts::BinUtility DefaultBin(const Acts::TrackingVolume& volume);

  Config m_cfg;

  const Logger& logger() const { return *m_cfg.logger; }
};

}  // namespace Acts