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/Geometry/GeometryContext.hpp"
#include "Acts/Geometry/GeometryIdentifier.hpp"
#include "Acts/MagneticField/MagneticFieldContext.hpp"
#include "Acts/Material/AccumulatedVolumeMaterial.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/Propagator/SurfaceCollector.hpp"
#include "Acts/Propagator/VolumeCollector.hpp"
#include "Acts/Utilities/Definitions.hpp"
#include "Acts/Utilities/Logger.hpp"
#include "Acts/Utilities/detail/Axis.hpp"
#include "Acts/Utilities/detail/Grid.hpp"

namespace Acts {

using RecordedMaterialVolumePoint =
    std::vector<std::pair<Acts::MaterialSlab, std::vector<Acts::Vector3D>>>;

//

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

  struct Config {
    float mappingStep = 1.;
  };

  struct State {
    State(std::reference_wrapper<const GeometryContext> gctx,
          std::reference_wrapper<const MagneticFieldContext> mctx)
        : geoContext(gctx), magFieldContext(mctx) {}

    std::map<GeometryIdentifier, RecordedMaterialVolumePoint> recordedMaterial;

    std::map<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(RecordedMaterialVolumePoint& matPoint,
                       Acts::MaterialSlab properties, Vector3D position,
                       Vector3D direction) const;

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

  Config m_cfg;

  StraightLinePropagator m_propagator;

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

}  // namespace Acts