MaterialValidationBase.cpp

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

// This file is part of the Acts project.
//
// Copyright (C) 2017-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/.

#include "Acts/Propagator/DefaultExtension.hpp"
#include "Acts/Propagator/DenseEnvironmentExtension.hpp"
#include "ActsExamples/Detector/IBaseDetector.hpp"
#include "ActsExamples/Framework/RandomNumbers.hpp"
#include "ActsExamples/Framework/Sequencer.hpp"
#include "ActsExamples/Geometry/CommonGeometry.hpp"
#include "ActsExamples/Io/Root/RootMaterialTrackWriter.hpp"
#include "ActsExamples/Options/CommonOptions.hpp"
#include "ActsExamples/Plugins/BField/BFieldOptions.hpp"
#include "ActsExamples/Plugins/BField/ScalableBField.hpp"
#include "ActsExamples/Propagation/PropagationAlgorithm.hpp"
#include "ActsExamples/Propagation/PropagationOptions.hpp"
#include "ActsExamples/Utilities/Paths.hpp"
#include <Acts/Geometry/TrackingGeometry.hpp>
#include <Acts/MagneticField/ConstantBField.hpp>
#include <Acts/MagneticField/InterpolatedBFieldMap.hpp>
#include <Acts/MagneticField/SharedBField.hpp>
#include <Acts/Propagator/EigenStepper.hpp>
#include <Acts/Propagator/Navigator.hpp>
#include <Acts/Propagator/Propagator.hpp>
#include <Acts/Propagator/StraightLineStepper.hpp>

#include <memory>

#include <boost/program_options.hpp>

namespace po = boost::program_options;

namespace {
template <typename bfield_t>
ActsExamples::ProcessCode setupPropagation(
    ActsExamples::Sequencer& sequencer, bfield_t bfield, po::variables_map& vm,
    std::shared_ptr<ActsExamples::RandomNumbers> randomNumberSvc,
    std::shared_ptr<const Acts::TrackingGeometry> tGeometry) {
  // Get the log level
  auto logLevel = ActsExamples::Options::readLogLevel(vm);

  // Get a Navigator
  Acts::Navigator navigator(tGeometry);
  navigator.resolvePassive = true;
  navigator.resolveMaterial = true;
  navigator.resolveSensitive = true;

  // Resolve the bfield map template and create the propgator
  using Stepper = Acts::EigenStepper<
      bfield_t,
      Acts::StepperExtensionList<Acts::DefaultExtension,
                                 Acts::DenseEnvironmentExtension>,
      Acts::detail::HighestValidAuctioneer>;
  using Propagator = Acts::Propagator<Stepper, Acts::Navigator>;
  Stepper stepper(std::move(bfield));
  Propagator propagator(std::move(stepper), std::move(navigator));

  // Read the propagation config and create the algorithms
  auto pAlgConfig =
      ActsExamples::Options::readPropagationConfig(vm, propagator);
  pAlgConfig.randomNumberSvc = randomNumberSvc;
  pAlgConfig.recordMaterialInteractions = true;
  auto propagationAlg =
      std::make_shared<ActsExamples::PropagationAlgorithm<Propagator>>(
          pAlgConfig, logLevel);

  // Add the propagation algorithm
  sequencer.addAlgorithm({propagationAlg});

  return ActsExamples::ProcessCode::SUCCESS;
}

ActsExamples::ProcessCode setupStraightLinePropagation(
    ActsExamples::Sequencer& sequencer, po::variables_map& vm,
    std::shared_ptr<ActsExamples::RandomNumbers> randomNumberSvc,
    std::shared_ptr<const Acts::TrackingGeometry> tGeometry) {
  // Get the log level
  auto logLevel = ActsExamples::Options::readLogLevel(vm);

  // Get a Navigator
  Acts::Navigator navigator(tGeometry);

  // Straight line stepper
  using SlStepper = Acts::StraightLineStepper;
  using Propagator = Acts::Propagator<SlStepper, Acts::Navigator>;
  // Make stepper and propagator
  SlStepper stepper;
  Propagator propagator(std::move(stepper), std::move(navigator));

  // Read the propagation config and create the algorithms
  auto pAlgConfig =
      ActsExamples::Options::readPropagationConfig(vm, propagator);
  pAlgConfig.randomNumberSvc = randomNumberSvc;
  auto propagationAlg =
      std::make_shared<ActsExamples::PropagationAlgorithm<Propagator>>(
          pAlgConfig, logLevel);

  // Add the propagation algorithm
  sequencer.addAlgorithm({propagationAlg});

  return ActsExamples::ProcessCode::SUCCESS;
}

}  // namespace

int materialValidationExample(int argc, char* argv[],
                              ActsExamples::IBaseDetector& detector) {
  // Setup and parse options
  auto desc = ActsExamples::Options::makeDefaultOptions();
  ActsExamples::Options::addSequencerOptions(desc);
  ActsExamples::Options::addGeometryOptions(desc);
  ActsExamples::Options::addMaterialOptions(desc);
  ActsExamples::Options::addBFieldOptions(desc);
  ActsExamples::Options::addRandomNumbersOptions(desc);
  ActsExamples::Options::addPropagationOptions(desc);
  ActsExamples::Options::addOutputOptions(desc);

  // Add specific options for this geometry
  detector.addOptions(desc);
  auto vm = ActsExamples::Options::parse(desc, argc, argv);
  if (vm.empty()) {
    return EXIT_FAILURE;
  }

  ActsExamples::Sequencer sequencer(
      ActsExamples::Options::readSequencerConfig(vm));

  // Now read the standard options
  auto logLevel = ActsExamples::Options::readLogLevel(vm);

  // The geometry, material and decoration
  auto geometry = ActsExamples::Geometry::build(vm, detector);
  auto tGeometry = geometry.first;
  auto contextDecorators = geometry.second;

  // Create the random number engine
  auto randomNumberSvcCfg = ActsExamples::Options::readRandomNumbersConfig(vm);
  auto randomNumberSvc =
      std::make_shared<ActsExamples::RandomNumbers>(randomNumberSvcCfg);

  // Create BField service
  auto bFieldVar = ActsExamples::Options::readBField(vm);

  if (vm["prop-stepper"].template as<int>() == 0) {
    // Straight line stepper was chosen
    setupStraightLinePropagation(sequencer, vm, randomNumberSvc, tGeometry);
  } else {
    std::visit(
        [&](auto& bField) {
          using field_type =
              typename std::decay_t<decltype(bField)>::element_type;
          Acts::SharedBField<field_type> fieldMap(bField);
          setupPropagation(sequencer, fieldMap, vm, randomNumberSvc, tGeometry);
        },
        bFieldVar);
  }

  // ---------------------------------------------------------------------------------
  // Output directory
  std::string outputDir = vm["output-dir"].template as<std::string>();
  auto matCollection = vm["prop-material-collection"].as<std::string>();

  if (vm["output-root"].template as<bool>()) {
    // Write the propagation steps as ROOT TTree
    ActsExamples::RootMaterialTrackWriter::Config matTrackWriterRootConfig;
    matTrackWriterRootConfig.collection = matCollection;
    matTrackWriterRootConfig.filePath =
        ActsExamples::joinPaths(outputDir, matCollection + ".root");
    matTrackWriterRootConfig.storeSurface = true;
    matTrackWriterRootConfig.storeVolume = true;
    auto matTrackWriterRoot =
        std::make_shared<ActsExamples::RootMaterialTrackWriter>(
            matTrackWriterRootConfig, logLevel);
    sequencer.addWriter(matTrackWriterRoot);
  }

  // Initiate the run
  sequencer.run();
  // Return success code
  return 0;
}