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

#include "Acts/Geometry/GeometryContext.hpp"
#include "Acts/Geometry/GeometryID.hpp"
#include "Acts/MagneticField/MagneticFieldContext.hpp"
#include "Acts/Material/AccumulatedVolumeMaterial.hpp"
#include "Acts/Material/MaterialProperties.hpp"
#include "Acts/Propagator/MaterialInteractor.hpp"
#include "Acts/Propagator/Navigator.hpp"
#include "Acts/Propagator/Propagator.hpp"
#include "Acts/Propagator/StraightLineStepper.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 RecordedMaterialPoint =
    std::vector<std::pair<Acts::MaterialProperties, Acts::Vector3D>>;

//

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

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

  struct Config {
    float mappingStep = 1.;
    bool mapperDebugOutput = false;
  };

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

    std::map<GeometryID, RecordedMaterialPoint> recordedMaterial;

    std::map<GeometryID, BinUtility> materialBin;

    std::map<GeometryID, 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:
  void resolveMaterialVolume(State& mState,
                             const TrackingVolume& tVolume) const;

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

  void collectMaterialSurface(State& /*mState*/,
                              const TrackingVolume& tVolume) const;

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

  Config m_cfg;

  StraightLinePropagator m_propagator;

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

}  // namespace Acts