Interactor.hpp

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

// This file is part of the Acts project.
//
// Copyright (C) 2018 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/MaterialProperties.hpp"
#include "Acts/Propagator/ActionList.hpp"
#include "Acts/Surfaces/Surface.hpp"
#include "Fatras/Kernel/PhysicsList.hpp"
#include "detail/RandomNumberDistributions.hpp"
#include <climits>
#include <cmath>
#include <sstream>
#include <utility>

namespace Fatras {

struct VoidSelector {

  bool operator()(const Acts::Surface &) const { return false; }
};

template <typename generator_t, typename particle_t, typename hit_t,
          typename hit_creator_t, typename sensitive_selector_t = VoidSelector,
          typename physics_list_t = PhysicsList<>>
struct Interactor {
  using PhysicsList_t = physics_list_t;

  generator_t *generator = nullptr;

  sensitive_selector_t sensitiveSelector;

  physics_list_t physicsList;

  particle_t initialParticle;

  hit_creator_t hitCreator;

  struct this_result {

    bool initialized = false;

    particle_t particle;

    std::vector<particle_t> outgoing;

    std::vector<hit_t> simulatedHits;
  };

  typedef this_result result_type;

  template <typename propagator_state_t, typename stepper_t>
  void operator()(propagator_state_t &state, stepper_t &stepper,
                  result_type &result) const {

    // If we are on target, everything should have been done
    if (state.navigation.targetReached)
      return;

    // Initialize the result, the state is thread local
    if (!result.initialized) {
      // set the initial particle parameters
      result.particle = initialParticle;
      result.initialized = true;
    }
    // get position and momentum presetp
    auto position = stepper.position(state.stepping);
    auto direction = stepper.direction(state.stepping);
    auto p = stepper.momentum(state.stepping);

    // set the stepping position to the particle
    result.particle.update(position, p * direction, 0., 0.,
                           stepper.time(state.stepping));

    // Check if the current surrface a senstive one
    bool sensitive = state.navigation.currentSurface
                         ? sensitiveSelector(*state.navigation.currentSurface)
                         : false;
    double depositedEnergy = 0.;

    // a current surface has been assigned by the navigator
    if (state.navigation.currentSurface &&
        state.navigation.currentSurface->surfaceMaterial()) {
      // get the surface material and the corresponding material properties
      auto sMaterial = state.navigation.currentSurface->surfaceMaterial();
      const Acts::MaterialProperties &mProperties =
          sMaterial->materialProperties(position);
      bool breakIndicator = false;
      if (mProperties) {
        // run the Fatras physics list - only when there's material
        breakIndicator = physicsList(*generator, mProperties, result.particle,
                                     result.outgoing);
      }
    }
    // Update the stepper cache with the current particle parameters
    position = result.particle.position();
    direction = result.particle.momentum().normalized();
    stepper.update(state.stepping, position, direction, result.particle.p(),
                   result.particle.time());
    // create the hit on a senstive element
    if (sensitive) {
      // create and fill the hit
      double htime =
          stepper.time(state.stepping); 
      hit_t simHit =
          hitCreator(*state.navigation.currentSurface, position, direction,
                     depositedEnergy, htime, result.particle);
      result.simulatedHits.push_back(std::move(simHit));
    }
  }

  template <typename propagator_state_t, typename stepper_t>
  void operator()(propagator_state_t &, stepper_t &) const {}
};
} // namespace Fatras