MaterialCollector.hpp

Go to the documentation of this file. Or view the newest version in sPHENIX GitHub for file MaterialCollector.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

#include "Acts/Material/ISurfaceMaterial.hpp"
#include "Acts/Material/Material.hpp"
#include "Acts/Material/MaterialSlab.hpp"
#include "Acts/Surfaces/Surface.hpp"

#include <sstream>

namespace Acts {

struct MaterialHit {
  const Surface* surface = nullptr;
  Vector3 position;
  Vector3 direction;
  Material material;
  double pathLength;
};

struct MaterialCollector {
  bool detailedCollection = false;

  struct this_result {
    std::vector<MaterialHit> collected;
    double materialInX0 = 0.;
    double materialInL0 = 0.;
  };

  using result_type = this_result;

  template <typename propagator_state_t, typename stepper_t,
            typename navigator_t>
  void operator()(propagator_state_t& state, const stepper_t& stepper,
                  const navigator_t& navigator, result_type& result,
                  const Logger& logger) const {
    if (navigator.currentSurface(state.navigation)) {
      if (navigator.currentSurface(state.navigation) ==
              navigator.targetSurface(state.navigation) and
          not navigator.targetReached(state.navigation)) {
        return;
      }

      ACTS_VERBOSE("Material check on surface "
                   << navigator.currentSurface(state.navigation)->geometryId());

      if (navigator.currentSurface(state.navigation)->surfaceMaterial()) {
        // get the material propertices and only continue
        const MaterialSlab* mProperties =
            navigator.currentSurface(state.navigation)
                ->surfaceMaterial()
                ->material(stepper.position(state.stepping));
        if (mProperties) {
          // pre/post/full update
          double prepofu = 1.;
          if (navigator.startSurface(state.navigation) ==
              navigator.currentSurface(state.navigation)) {
            ACTS_VERBOSE("Update on start surface: post-update mode.");
            prepofu = navigator.currentSurface(state.navigation)
                          ->surfaceMaterial()
                          ->factor(state.options.direction,
                                   MaterialUpdateStage::PostUpdate);
          } else if (navigator.targetSurface(state.navigation) ==
                     navigator.currentSurface(state.navigation)) {
            ACTS_VERBOSE("Update on target surface: pre-update mode");
            prepofu = navigator.currentSurface(state.navigation)
                          ->surfaceMaterial()
                          ->factor(state.options.direction,
                                   MaterialUpdateStage::PreUpdate);
          } else {
            ACTS_VERBOSE("Update while pass through: full mode.");
          }

          // the pre/post factor has been applied
          // now check if there's still something to do
          if (prepofu == 0.) {
            ACTS_VERBOSE("Pre/Post factor set material to zero.");
            return;
          }
          // more debugging output to the screen
          ACTS_VERBOSE("Material properties found for this surface.");

          // the path correction from the surface intersection
          double pCorrection =
              prepofu * navigator.currentSurface(state.navigation)
                            ->pathCorrection(stepper.position(state.stepping),
                                             stepper.direction(state.stepping));
          // the full material
          result.materialInX0 += pCorrection * mProperties->thicknessInX0();
          result.materialInL0 += pCorrection * mProperties->thicknessInL0();

          ACTS_VERBOSE("t/X0 (t/L0) increased to "
                       << result.materialInX0 << " (" << result.materialInL0
                       << " )");

          // if configured, record the individual material hits
          if (detailedCollection) {
            // create for recording
            MaterialHit mHit;
            mHit.surface = navigator.currentSurface(state.navigation);
            mHit.position = stepper.position(state.stepping);
            mHit.direction = stepper.direction(state.stepping);
            // get the material & path length
            mHit.material = mProperties->material();
            mHit.pathLength = pCorrection * mProperties->thickness();
            // save if in the result
            result.collected.push_back(mHit);
          }
        }
      }
    }
  }
};  // namespace Acts
}  // namespace Acts