df/dea/RecCKFTracks_8cpp_source.html

// 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/.


#include "ActsExamples/Digitization/HitSmearing.hpp"

#include "ActsExamples/Framework/Sequencer.hpp"

#include "ActsExamples/Framework/WhiteBoard.hpp"

#include "ActsExamples/GenericDetector/GenericDetector.hpp"

#include "ActsExamples/Geometry/CommonGeometry.hpp"

#include "ActsExamples/Io/Csv/CsvOptionsReader.hpp"

#include "ActsExamples/Io/Csv/CsvParticleReader.hpp"

#include "ActsExamples/Io/Csv/CsvPlanarClusterReader.hpp"

#include "ActsExamples/Io/Performance/CKFPerformanceWriter.hpp"

#include "ActsExamples/Options/CommonOptions.hpp"

#include "ActsExamples/Plugins/BField/BFieldOptions.hpp"

#include "ActsExamples/TrackFinding/TrackFindingAlgorithm.hpp"

#include "ActsExamples/TrackFinding/TrackFindingOptions.hpp"

#include "ActsExamples/TruthTracking/ParticleSmearing.hpp"

#include "ActsExamples/TruthTracking/TruthSeedSelector.hpp"

#include "ActsExamples/Utilities/Options.hpp"

#include "ActsExamples/Utilities/Paths.hpp"

#include <Acts/Utilities/Units.hpp>


#include <memory>


using namespace Acts::UnitLiterals;

using namespace ActsExamples;


int main(int argc, char* argv[]) {

  GenericDetector detector;


  // setup and parse options

  auto desc = ActsExamples::Options::makeDefaultOptions();

  Options::addSequencerOptions(desc);

  Options::addRandomNumbersOptions(desc);

  Options::addGeometryOptions(desc);

  Options::addMaterialOptions(desc);

  Options::addInputOptions(desc);

  Options::addOutputOptions(desc);

  detector.addOptions(desc);

  Options::addBFieldOptions(desc);

  Options::addTrackFindingOptions(desc);


  auto vm = Options::parse(desc, argc, argv);

  if (vm.empty()) {

    return EXIT_FAILURE;

  }


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


  // Read some standard options

  auto logLevel = Options::readLogLevel(vm);

  auto inputDir = vm["input-dir"].as<std::string>();

  auto outputDir = ensureWritableDirectory(vm["output-dir"].as<std::string>());

  auto rnd = std::make_shared<ActsExamples::RandomNumbers>(

      Options::readRandomNumbersConfig(vm));


  // Setup detector geometry

  auto geometry = Geometry::build(vm, detector);

  auto trackingGeometry = geometry.first;

  // Add context decorators

  for (auto cdr : geometry.second) {

    sequencer.addContextDecorator(cdr);

  }

  // Setup the magnetic field

  auto magneticField = Options::readBField(vm);


  // Read particles (initial states) and clusters from CSV files

  auto particleReader = Options::readCsvParticleReaderConfig(vm);

  particleReader.inputStem = "particles_initial";

  particleReader.outputParticles = "particles_initial";

  sequencer.addReader(

      std::make_shared<CsvParticleReader>(particleReader, logLevel));

  // Read clusters from CSV files

  auto clusterReaderCfg = Options::readCsvPlanarClusterReaderConfig(vm);

  clusterReaderCfg.trackingGeometry = trackingGeometry;

  clusterReaderCfg.outputClusters = "clusters";

  clusterReaderCfg.outputHitIds = "hit_ids";

  clusterReaderCfg.outputHitParticlesMap = "hit_particles_map";

  clusterReaderCfg.outputSimulatedHits = "hits";

  sequencer.addReader(

      std::make_shared<CsvPlanarClusterReader>(clusterReaderCfg, logLevel));


  // Pre-select particles

  // The pre-selection will select truth particles satisfying provided criteria

  // from all particles read in by particle reader for further processing. It

  // has no impact on the truth hits read-in by the cluster reader.

  // @TODO: add options for truth particle selection criteria

  TruthSeedSelector::Config particleSelectorCfg;

  particleSelectorCfg.inputParticles = particleReader.outputParticles;

  particleSelectorCfg.inputHitParticlesMap =

      clusterReaderCfg.outputHitParticlesMap;

  particleSelectorCfg.outputParticles = "particles_selected";

  particleSelectorCfg.ptMin = 1_GeV;

  particleSelectorCfg.nHitsMin = 9;

  sequencer.addAlgorithm(

      std::make_shared<TruthSeedSelector>(particleSelectorCfg, logLevel));


  // Create smeared measurements

  HitSmearing::Config hitSmearingCfg;

  hitSmearingCfg.inputSimulatedHits = clusterReaderCfg.outputSimulatedHits;

  hitSmearingCfg.outputSourceLinks = "sourcelinks";

  hitSmearingCfg.sigmaLoc0 = 25_um;

  hitSmearingCfg.sigmaLoc1 = 100_um;

  hitSmearingCfg.randomNumbers = rnd;

  hitSmearingCfg.trackingGeometry = trackingGeometry;

  sequencer.addAlgorithm(

      std::make_shared<HitSmearing>(hitSmearingCfg, logLevel));


  const auto& inputParticles = particleSelectorCfg.outputParticles;

  // Create smeared particles states

  ParticleSmearing::Config particleSmearingCfg;

  particleSmearingCfg.inputParticles = inputParticles;

  particleSmearingCfg.outputTrackParameters = "smearedparameters";

  particleSmearingCfg.randomNumbers = rnd;

  // Gaussian sigmas to smear particle parameters

  particleSmearingCfg.sigmaD0 = 20_um;

  particleSmearingCfg.sigmaD0PtA = 30_um;

  particleSmearingCfg.sigmaD0PtB = 0.3 / 1_GeV;

  particleSmearingCfg.sigmaZ0 = 20_um;

  particleSmearingCfg.sigmaZ0PtA = 30_um;

  particleSmearingCfg.sigmaZ0PtB = 0.3 / 1_GeV;

  particleSmearingCfg.sigmaPhi = 1_degree;

  particleSmearingCfg.sigmaTheta = 1_degree;

  particleSmearingCfg.sigmaPRel = 0.01;

  particleSmearingCfg.sigmaT0 = 1_ns;

  sequencer.addAlgorithm(

      std::make_shared<ParticleSmearing>(particleSmearingCfg, logLevel));


  // Setup the track finding algorithm with CKF

  // It takes all the source links created from truth hit smearing, seeds from

  // truth particle smearing and source link selection config

  auto trackFindingCfg = Options::readTrackFindingConfig(vm);

  trackFindingCfg.inputSourceLinks = hitSmearingCfg.outputSourceLinks;

  trackFindingCfg.inputInitialTrackParameters =

      particleSmearingCfg.outputTrackParameters;

  trackFindingCfg.outputTrajectories = "trajectories";

  trackFindingCfg.findTracks = TrackFindingAlgorithm::makeTrackFinderFunction(

      trackingGeometry, magneticField);

  sequencer.addAlgorithm(

      std::make_shared<TrackFindingAlgorithm>(trackFindingCfg, logLevel));


  // Write CKF performance data

  CKFPerformanceWriter::Config perfWriterCfg;

  perfWriterCfg.inputParticles = inputParticles;

  perfWriterCfg.inputTrajectories = trackFindingCfg.outputTrajectories;

  perfWriterCfg.outputDir = outputDir;

  sequencer.addWriter(

      std::make_shared<CKFPerformanceWriter>(perfWriterCfg, logLevel));


  return sequencer.run();

}