PointwiseMaterialInteraction.hpp

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

// This file is part of the Acts project.
//
// Copyright (C) 2019 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/MaterialSlab.hpp"
#include "Acts/Surfaces/Surface.hpp"

namespace Acts {
namespace detail {
struct PointwiseMaterialInteraction {
  const Surface* surface;

  const Vector3D pos = Vector3D(0., 0., 0);
  const double time = 0.0;
  const Vector3D dir = Vector3D(0., 0., 0);
  const double momentum;
  const double q;
  const double qOverP;
  const double mass;
  const int pdg;
  const bool performCovarianceTransport;
  const NavigationDirection nav;

  MaterialSlab slab;
  double pathCorrection;
  double variancePhi = 0.;
  double varianceTheta = 0.;
  double varianceQoverP = 0.;
  double Eloss = 0.;
  double nextP;

  template <typename propagator_state_t, typename stepper_t>
  PointwiseMaterialInteraction(const Surface* sSurface,
                               const propagator_state_t& state,
                               const stepper_t& stepper)
      : surface(sSurface),
        pos(stepper.position(state.stepping)),
        time(stepper.time(state.stepping)),
        dir(stepper.direction(state.stepping)),
        momentum(stepper.momentum(state.stepping)),
        q(stepper.charge(state.stepping)),
        qOverP(q / momentum),
        mass(state.options.mass),
        pdg(state.options.absPdgCode),
        performCovarianceTransport(state.stepping.covTransport),
        nav(state.stepping.navDir) {}

  template <typename propagator_state_t>
  bool evaluateMaterialSlab(const propagator_state_t& state,
                            MaterialUpdateStage updateStage = fullUpdate) {
    // We are at the start surface
    if (surface == state.navigation.startSurface) {
      updateStage = postUpdate;
      // Or is it the target surface ?
    } else if (surface == state.navigation.targetSurface) {
      updateStage = preUpdate;
    }

    // Retrieve the material properties
    slab = state.navigation.currentSurface->surfaceMaterial()->materialSlab(
        pos, nav, updateStage);

    // Correct the material properties for non-zero incidence
    pathCorrection = surface->pathCorrection(state.geoContext, pos, dir);
    slab.scaleThickness(pathCorrection);

    // Get the surface material & properties from them
    return slab;
  }

  void evaluatePointwiseMaterialInteraction(bool multipleScattering,
                                            bool energyLoss);

  template <typename propagator_state_t, typename stepper_t>
  void updateState(propagator_state_t& state, const stepper_t& stepper) {
    // in forward(backward) propagation, energy decreases(increases) and
    // variances increase(decrease)
    const auto nextE = std::sqrt(mass * mass + momentum * momentum) -
                       std::copysign(Eloss, nav);
    // put particle at rest if energy loss is too large
    nextP = (mass < nextE) ? std::sqrt(nextE * nextE - mass * mass) : 0;
    // update track parameters and covariance
    stepper.update(state.stepping, pos, dir, nextP, time);
    // Update covariance matrix
    NoiseUpdateMode mode = (nav == forward) ? addNoise : removeNoise;
    state.stepping.cov(eBoundPhi, eBoundPhi) = updateVariance(
        state.stepping.cov(eBoundPhi, eBoundPhi), variancePhi, mode);
    state.stepping.cov(eBoundTheta, eBoundTheta) = updateVariance(
        state.stepping.cov(eBoundTheta, eBoundTheta), varianceTheta, mode);
    state.stepping.cov(eBoundQOverP, eBoundQOverP) = updateVariance(
        state.stepping.cov(eBoundQOverP, eBoundQOverP), varianceQoverP, mode);
  }

 private:
  void covarianceContributions(bool multipleScattering, bool energyLoss);

  double updateVariance(double variance, double change,
                        NoiseUpdateMode updateMode = addNoise) const;
};
}  // namespace detail
}  // end of namespace Acts