NuclearInteractionParametrisation.hpp

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

// This file is part of the Acts project.
//
// Copyright (C) 2020-2021 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/Definitions/Algebra.hpp"
#include "ActsExamples/EventData/ExtractedSimulationProcess.hpp"
#include "ActsExamples/EventData/SimParticle.hpp"

#include <algorithm>
#include <cstdint>
#include <tuple>
#include <unordered_map>
#include <utility>
#include <vector>

#include <TH1F.h>
#include <TVectorFfwd.h>

namespace ActsExamples {
namespace detail {
namespace NuclearInteractionParametrisation {

struct EventFraction {
  EventFraction() = default;

  EventFraction(const ActsExamples::ExtractedSimulationProcess& event)
      : initialParticle(event.initial),
        interactingParticle(event.before),
        finalParticles(event.after) {}

  ActsExamples::SimParticle initialParticle;
  ActsExamples::SimParticle interactingParticle;
  std::vector<ActsExamples::SimParticle> finalParticles;

  bool soft = false;
  unsigned int multiplicity = 0;
  float initialMomentum = 0.;
};

static constexpr uint32_t s_MaxValue = UINT32_MAX;
using EventCollection = std::vector<EventFraction>;
using EventProperties = std::vector<std::vector<float>>;
using ProbabilityDistributions = std::vector<TH1F*>;
using CumulativeDistribution = TH1F*;
using Vector = Acts::ActsDynamicVector;
using Matrix = Acts::ActsDynamicMatrix;
using EigenspaceComponents = std::tuple<Vector, Matrix, Vector>;
using Parametrisation =
    std::pair<EigenspaceComponents, std::vector<CumulativeDistribution>>;

EventProperties prepareMomenta(const EventCollection& events,
                               unsigned int multiplicity, bool soft);

ProbabilityDistributions buildMomPerMult(const EventProperties& events,
                                         unsigned int nBins);

EventProperties convertEventToGaussian(const ProbabilityDistributions& histos,
                                       const EventProperties& events);

std::pair<Vector, Matrix> calculateMeanAndCovariance(
    unsigned int multiplicity, const EventProperties& events);

EigenspaceComponents calculateEigenspace(const Vector& mean,
                                         const Matrix& covariance);

Parametrisation buildMomentumParameters(const EventCollection& events,
                                        unsigned int multiplicity, bool soft,
                                        unsigned int nBins);

EventProperties prepareInvariantMasses(const EventCollection& events,
                                       unsigned int multiplicity, bool soft);

Parametrisation buildInvariantMassParameters(const EventCollection& events,
                                             unsigned int multiplicity,
                                             bool soft, unsigned int nBins);

std::unordered_map<int, std::unordered_map<int, float>>
cumulativePDGprobability(const EventCollection& events);

std::pair<CumulativeDistribution, CumulativeDistribution>
cumulativeMultiplicityProbability(const EventCollection& events,
                                  unsigned int multiplicityMax);

TVectorF softProbability(const EventCollection& events);

CumulativeDistribution cumulativeNuclearInteractionProbability(
    const EventCollection& events, unsigned int interactionProbabilityBins);
}  // namespace NuclearInteractionParametrisation
}  // namespace detail
}  // namespace ActsExamples