VolumeMaterialMapper.hpp

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

// This file is part of the Acts project.
//
// Copyright (C) 2019-2020 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

// Workaround for building on clang+libstdc++
#include "Acts/Utilities/detail/ReferenceWrapperAnyCompat.hpp"

#include "Acts/Definitions/Algebra.hpp"
#include "Acts/Geometry/GeometryContext.hpp"
#include "Acts/Geometry/GeometryIdentifier.hpp"
#include "Acts/Geometry/TrackingVolume.hpp"
#include "Acts/MagneticField/MagneticFieldContext.hpp"
#include "Acts/Material/AccumulatedVolumeMaterial.hpp"
#include "Acts/Material/MaterialGridHelper.hpp"
#include "Acts/Material/MaterialInteraction.hpp"
#include "Acts/Material/MaterialSlab.hpp"
#include "Acts/Propagator/MaterialInteractor.hpp"
#include "Acts/Propagator/Navigator.hpp"
#include "Acts/Propagator/Propagator.hpp"
#include "Acts/Propagator/StraightLineStepper.hpp"
#include "Acts/Surfaces/Surface.hpp"
#include "Acts/Utilities/BinUtility.hpp"
#include "Acts/Utilities/Logger.hpp"

#include <functional>
#include <map>
#include <memory>
#include <utility>
#include <vector>

namespace Acts {

class ISurfaceMaterial;
class IVolumeMaterial;
class TrackingGeometry;

//

class VolumeMaterialMapper {
 public:
  using StraightLinePropagator = Propagator<StraightLineStepper, Navigator>;

  struct Config {
    float mappingStep = 1.;
  };

  struct State {
    State(const GeometryContext& gctx, const MagneticFieldContext& mctx)
        : geoContext(gctx), magFieldContext(mctx) {}

    std::map<const GeometryIdentifier, Acts::AccumulatedVolumeMaterial>
        homogeneousGrid;

    std::map<const GeometryIdentifier,
             std::function<Acts::Vector2(Acts::Vector3)>>
        transform2D;

    std::map<const GeometryIdentifier, Grid2D> grid2D;

    std::map<const GeometryIdentifier,
             std::function<Acts::Vector3(Acts::Vector3)>>
        transform3D;

    std::map<const GeometryIdentifier, Grid3D> grid3D;

    std::map<const GeometryIdentifier, BinUtility> materialBin;

    std::map<GeometryIdentifier, std::shared_ptr<const ISurfaceMaterial>>
        surfaceMaterial;

    std::map<GeometryIdentifier, std::unique_ptr<const IVolumeMaterial>>
        volumeMaterial;

    std::reference_wrapper<const GeometryContext> geoContext;

    std::reference_wrapper<const MagneticFieldContext> magFieldContext;
  };

  VolumeMaterialMapper() = delete;

  VolumeMaterialMapper(const Config& cfg, StraightLinePropagator propagator,
                       std::unique_ptr<const Logger> slogger = getDefaultLogger(
                           "VolumeMaterialMapper", Logging::INFO));

  State createState(const GeometryContext& gctx,
                    const MagneticFieldContext& mctx,
                    const TrackingGeometry& tGeometry) const;

  void finalizeMaps(State& mState) const;

  void mapMaterialTrack(State& mState, RecordedMaterialTrack& mTrack) const;

 private:
  struct BoundSurfaceSelector {
    bool operator()(const Surface& sf) const {
      return (sf.geometryId().boundary() != 0);
    }
  };

  struct MaterialVolumeSelector {
    bool operator()(const TrackingVolume& vf) const {
      return (vf.volumeMaterial() != nullptr);
    }
  };

  void resolveMaterialVolume(State& mState,
                             const TrackingVolume& tVolume) const;

  void checkAndInsert(State& mState, const TrackingVolume& volume) const;

  void collectMaterialSurfaces(State& mState,
                               const TrackingVolume& tVolume) const;

  void createExtraHits(
      State& mState,
      std::pair<const GeometryIdentifier, BinUtility>& currentBinning,
      Acts::MaterialSlab properties, const Vector3& position,
      Vector3 direction) const;

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

  Config m_cfg;

  StraightLinePropagator m_propagator;

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

}  // namespace Acts