SurfaceMaterialMapper.hpp

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

// This file is part of the Acts project.
//
// Copyright (C) 2018-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/Geometry/TrackingVolume.hpp"
#include "Acts/MagneticField/MagneticFieldContext.hpp"
#include "Acts/Material/AccumulatedSurfaceMaterial.hpp"
#include "Acts/Material/ISurfaceMaterial.hpp"
#include "Acts/Material/MaterialInteraction.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/Surfaces/Surface.hpp"
#include "Acts/Utilities/Logger.hpp"

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

namespace Acts {

class IVolumeMaterial;
class ISurfaceMaterial;
class TrackingGeometry;
struct MaterialInteraction;

struct MaterialSurface {
  bool operator()(const Surface& sf) const {
    return (sf.surfaceMaterial() != nullptr);
  }
};

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

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

  struct Config {
    std::array<double, 2> etaRange = {{-6., 6.}};
    bool emptyBinCorrection = true;
    bool mapperDebugOutput = false;
    bool computeVariance = false;
  };

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

    std::map<GeometryIdentifier, AccumulatedSurfaceMaterial>
        accumulatedMaterial;

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

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

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

    std::reference_wrapper<const GeometryContext> geoContext;

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

  SurfaceMaterialMapper() = delete;

  SurfaceMaterialMapper(const Config& cfg, StraightLinePropagator propagator,
                        std::unique_ptr<const Logger> slogger =
                            getDefaultLogger("SurfaceMaterialMapper",
                                             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;

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

  void mapSurfaceInteraction(State& mState,
                             std::vector<MaterialInteraction>& rMaterial) const;

 private:
  void resolveMaterialSurfaces(State& mState,
                               const TrackingVolume& tVolume) const;

  void checkAndInsert(State& mState, const Surface& surface) const;

  void collectMaterialVolumes(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