TrackState.hpp

Go to the documentation of this file. Or view the newest version in sPHENIX GitHub for file TrackState.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/EventData/Measurement.hpp"
#include "Acts/EventData/MeasurementHelpers.hpp"
#include "Acts/EventData/SourceLinkConcept.hpp"
#include "Acts/Utilities/ParameterDefinitions.hpp"

#include <optional>

namespace Acts {

enum TrackStateFlag {
  MeasurementFlag = 0,
  ParameterFlag = 1,
  OutlierFlag = 2,
  HoleFlag = 3,
  MaterialFlag = 4,
  NumTrackStateFlags = 5
};

using TrackStateType = std::bitset<TrackStateFlag::NumTrackStateFlags>;

class Surface;

template <typename source_link_t, typename parameters_t>
class TrackState {
  static_assert(SourceLinkConcept<source_link_t>,
                "Source link does not fulfill SourceLinkConcept");

 public:
  using SourceLink = source_link_t;
  using Parameters = parameters_t;
  using Jacobian = typename Parameters::CovMatrix_t;

  TrackState(SourceLink m) : m_surface(&m.referenceSurface()) {
    measurement.uncalibrated = std::move(m);
    m_typeFlags.set(MeasurementFlag);
  }

  TrackState(parameters_t p) {
    m_surface = &p.referenceSurface();
    parameter.predicted = std::move(p);
    m_typeFlags.set(ParameterFlag);
  }

  virtual ~TrackState() = default;

  TrackState(const TrackState& rhs)
      : parameter(rhs.parameter),
        measurement(rhs.measurement),
        m_surface(rhs.m_surface),
        m_typeFlags(rhs.m_typeFlags) {}

  TrackState(TrackState&& rhs)
      : parameter(std::move(rhs.parameter)),
        measurement(std::move(rhs.measurement)),
        m_surface(std::move(rhs.m_surface)),
        m_typeFlags(std::move(rhs.m_typeFlags)) {}

  TrackState& operator=(const TrackState& rhs) {
    parameter = rhs.parameter;
    measurement = rhs.measurement;
    m_surface = rhs.m_surface;
    m_typeFlags = rhs.m_typeFlags;
    return (*this);
  }

  TrackState& operator=(TrackState&& rhs) {
    parameter = std::move(rhs.parameter);
    measurement = std::move(rhs.measurement);
    m_surface = std::move(rhs.m_surface);
    m_typeFlags = std::move(rhs.m_typeFlags);
    return (*this);
  }

  const Surface& referenceSurface() const { return (*m_surface); }

  void setType(const TrackStateFlag& flag, bool status = true) {
    m_typeFlags.set(flag, status);
  }

  bool isType(const TrackStateFlag& flag) const {
    assert(flag < NumTrackStateFlags);
    return m_typeFlags.test(flag);
  }

  TrackStateType type() const { return m_typeFlags; }

  std::optional<size_t> size() {
    if (this->measurement.calibrated) {
      return MeasurementHelpers::getSize(*this->measurement.calibrated);
    }
    return std::nullopt;
  }

  struct {
    std::optional<Parameters> predicted{std::nullopt};
    std::optional<Parameters> filtered{std::nullopt};
    std::optional<Parameters> smoothed{std::nullopt};
    std::optional<Jacobian> jacobian{std::nullopt};
    double pathLength = 0.;
    double chi2 = 0;
  } parameter;

  struct {
    std::optional<SourceLink> uncalibrated{std::nullopt};
    std::optional<FittableMeasurement<SourceLink>> calibrated{std::nullopt};
  } measurement;

 private:
  const Surface* m_surface = nullptr;
  TrackStateType m_typeFlags;
};
}  // namespace Acts