VoidKalmanComponents.hpp

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

namespace Acts {

struct VoidKalmanComponents {
  template <typename measurement_t, typename parameters_t>
  Result<measurement_t> operator()(measurement_t m,
                                   const parameters_t& /*pars*/) const {
    return m;
  }

  template <typename measurements_t>
  Result<measurements_t> operator()(measurements_t ms) const {
    return std::move(ms);
  }
};

struct VoidMeasurementCalibrator {
  template <typename source_link_t, typename parameters_t>
  FittableMeasurement<source_link_t> operator()(
      const source_link_t& sl, const parameters_t& /*pars*/) const {
    static_assert(SourceLinkConcept<source_link_t>,
                  "Source link does fulfill SourceLinkConcept.");
    static_assert(
        concept ::converts_to<FittableMeasurement<source_link_t>,
                              concept ::detail_slc::dereferenceable_t,
                              source_link_t>,
        "For DefaultMeasurementCalibrator, source link needs to implement "
        "dereference operator");

    return *sl;
  }
};

struct VoidKalmanUpdater {
  template <typename track_state_t, typename predicted_state_t>
  auto operator()(track_state_t& /*m*/,
                  const predicted_state_t& predicted) const {
    return &(predicted.parameters);
  }
};

struct VoidKalmanSmoother {
  template <typename parameters_t, typename track_states_t>
  const parameters_t* operator()(track_states_t& /*states*/) const {
    return nullptr;
  }
};

struct VoidOutlierFinder {
  template <typename track_state_t>
  constexpr bool operator()(const track_state_t& trackState) const {
    return false;
  }
};

}  // namespace Acts