SingleBoundTrackParameters.hpp

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

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

#pragma once
#include "Acts/EventData/SingleTrackParameters.hpp"
#include "Acts/Geometry/GeometryContext.hpp"
#include "Acts/Surfaces/Surface.hpp"

namespace Acts {

template <class ChargePolicy>
class SingleBoundTrackParameters : public SingleTrackParameters<ChargePolicy> {
 public:
  using ParVector_t = typename SingleTrackParameters<ChargePolicy>::ParVector_t;
  using CovMatrix_t = typename SingleTrackParameters<ChargePolicy>::CovMatrix_t;

  template <typename T = ChargePolicy,
            std::enable_if_t<std::is_same<T, ChargedPolicy>::value, int> = 0>
  SingleBoundTrackParameters(const GeometryContext& gctx,
                             std::optional<CovMatrix_t> cov,
                             const ParVector_t& parValues,
                             std::shared_ptr<const Surface> surface)
      : SingleTrackParameters<ChargePolicy>(
            std::move(cov), parValues,
            detail::coordinate_transformation::parameters2globalPosition(
                gctx, parValues, *surface),
            detail::coordinate_transformation::parameters2globalMomentum(
                parValues)),
        m_pSurface(std::move(surface)) {
    assert(m_pSurface);
  }

  template <typename T = ChargePolicy,
            std::enable_if_t<std::is_same<T, ChargedPolicy>::value, int> = 0>
  SingleBoundTrackParameters(const GeometryContext& gctx,
                             std::optional<CovMatrix_t> cov,
                             const ActsVectorD<3>& position,
                             const ActsVectorD<3>& momentum, double dCharge,
                             double dTime,
                             std::shared_ptr<const Surface> surface)
      : SingleTrackParameters<ChargePolicy>(
            std::move(cov),
            detail::coordinate_transformation::global2parameters(
                gctx, position, momentum, dCharge, dTime, *surface),
            position, momentum),
        m_pSurface(std::move(surface)) {
    assert(m_pSurface);
  }

  template <typename T = ChargePolicy,
            std::enable_if_t<std::is_same<T, NeutralPolicy>::value, int> = 0>
  SingleBoundTrackParameters(const GeometryContext& gctx,
                             std::optional<CovMatrix_t> cov,
                             const ParVector_t& parValues,
                             std::shared_ptr<const Surface> surface)
      : SingleTrackParameters<ChargePolicy>(
            std::move(cov), parValues,
            detail::coordinate_transformation::parameters2globalPosition(
                gctx, parValues, *surface),
            detail::coordinate_transformation::parameters2globalMomentum(
                parValues)),
        m_pSurface(std::move(surface)) {
    assert(m_pSurface);
  }

  template <typename T = ChargePolicy,
            std::enable_if_t<std::is_same<T, NeutralPolicy>::value, int> = 0>
  SingleBoundTrackParameters(const GeometryContext& gctx,
                             std::optional<CovMatrix_t> cov,
                             const ActsVectorD<3>& position,
                             const ActsVectorD<3>& momentum, double dTime,
                             std::shared_ptr<const Surface> surface)
      : SingleTrackParameters<ChargePolicy>(
            std::move(cov),
            detail::coordinate_transformation::global2parameters(
                gctx, position, momentum, 0, dTime, *surface),
            position, momentum),
        m_pSurface(std::move(surface)) {}

  SingleBoundTrackParameters(
      const SingleBoundTrackParameters<ChargePolicy>& copy)
      : SingleTrackParameters<ChargePolicy>(copy) {
    m_pSurface = copy.m_pSurface;
  }

  SingleBoundTrackParameters(SingleBoundTrackParameters<ChargePolicy>&& other)
      : SingleTrackParameters<ChargePolicy>(std::move(other)),
        m_pSurface(std::move(other.m_pSurface)) {}

  ~SingleBoundTrackParameters() final = default;

  SingleBoundTrackParameters<ChargePolicy>& operator=(
      const SingleBoundTrackParameters<ChargePolicy>& rhs) {
    // check for self-assignment
    if (this != &rhs) {
      SingleTrackParameters<ChargePolicy>::operator=(rhs);
      m_pSurface = rhs.m_pSurface;
    }
    return *this;
  }

  SingleBoundTrackParameters<ChargePolicy>& operator=(
      SingleBoundTrackParameters<ChargePolicy>&& rhs) {
    // check for self-assignment
    if (this != &rhs) {
      SingleTrackParameters<ChargePolicy>::operator=(std::move(rhs));
      m_pSurface = std::move(rhs.m_pSurface);
    }

    return *this;
  }

  //
  template <ParID_t par>
  void set(const GeometryContext& gctx, ParValue_t newValue) {
    this->getParameterSet().template setParameter<par>(newValue);
    this->updateGlobalCoordinates(gctx, BoundParameterType<par>());
  }

  const Surface& referenceSurface() const final { return *m_pSurface; }

  RotationMatrix3D referenceFrame(const GeometryContext& gctx) const {
    return std::move(
        m_pSurface->referenceFrame(gctx, this->position(), this->momentum()));
  }

 private:
  std::shared_ptr<const Surface> m_pSurface;
};

}  // namespace Acts