SingleCurvilinearTrackParameters.hpp

Go to the documentation of this file. Or view the newest version in sPHENIX GitHub for file SingleCurvilinearTrackParameters.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 <memory>
#include "Acts/EventData/SingleTrackParameters.hpp"
#include "Acts/Geometry/GeometryContext.hpp"
#include "Acts/Surfaces/PlaneSurface.hpp"

namespace Acts {

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

  template <typename T = ChargePolicy,
            std::enable_if_t<std::is_same<T, ChargedPolicy>::value, int> = 0>
  SingleCurvilinearTrackParameters(std::optional<CovMatrix_t> cov,
                                   const ActsVectorD<3>& position,
                                   const ActsVectorD<3>& momentum,
                                   double dCharge, double dTime)
      : SingleTrackParameters<ChargePolicy>(
            std::move(cov),
            detail::coordinate_transformation::global2curvilinear(
                position, momentum, dCharge, dTime),
            position, momentum),
        m_upSurface(Surface::makeShared<PlaneSurface>(position, momentum)) {}

  template <typename T = ChargePolicy,
            std::enable_if_t<std::is_same<T, NeutralPolicy>::value, int> = 0>
  SingleCurvilinearTrackParameters(std::optional<CovMatrix_t> cov,
                                   const ActsVectorD<3>& position,
                                   const ActsVectorD<3>& momentum, double dTime)
      : SingleTrackParameters<ChargePolicy>(
            std::move(cov),
            detail::coordinate_transformation::global2curvilinear(
                position, momentum, 0, dTime),
            position, momentum),
        m_upSurface(Surface::makeShared<PlaneSurface>(position, momentum)) {}

  SingleCurvilinearTrackParameters(
      const SingleCurvilinearTrackParameters<ChargePolicy>& copy)
      : SingleTrackParameters<ChargePolicy>(copy),
        m_upSurface(copy.m_upSurface)  // copy shared ptr
  {}

  SingleCurvilinearTrackParameters(
      SingleCurvilinearTrackParameters<ChargePolicy>&& other)
      : SingleTrackParameters<ChargePolicy>(std::move(other)),
        m_upSurface(std::move(other.m_upSurface)) {}

  ~SingleCurvilinearTrackParameters() final = default;

  SingleCurvilinearTrackParameters<ChargePolicy>& operator=(
      const SingleCurvilinearTrackParameters<ChargePolicy>& rhs) {
    // check for self-assignment
    if (this != &rhs) {
      SingleTrackParameters<ChargePolicy>::operator=(rhs);
      m_upSurface =
          Surface::makeShared<PlaneSurface>(this->position(), this->momentum());
    }
    return *this;
  }

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

  template <
      ParID_t par,
      std::enable_if_t<std::is_same_v<BoundParameterType<par>, local_parameter>,
                       int> = 0>
  void set(const GeometryContext& gctx, ParValue_t newValue) {
    // set the parameter & update the new global position
    this->getParameterSet().template setParameter<par>(newValue);
    this->updateGlobalCoordinates(gctx, BoundParameterType<par>());
    // recreate the surface
    m_upSurface = Surface::makeShared<PlaneSurface>(
        this->position(), this->momentum().normalized());
    // reset to (0,0)
    this->getParameterSet().template setParameter<par>(0.);
  }

  template <ParID_t par,
            std::enable_if_t<
                not std::is_same_v<BoundParameterType<par>, local_parameter>,
                int> = 0>
  void set(const GeometryContext& gctx, ParValue_t newValue) {
    this->getParameterSet().template setParameter<par>(newValue);
    this->updateGlobalCoordinates(gctx, BoundParameterType<par>());
    // recreate the surface
    m_upSurface = Surface::makeShared<PlaneSurface>(
        this->position(), this->momentum().normalized());
  }

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

  RotationMatrix3D referenceFrame(const GeometryContext& gctx) const {
    return m_upSurface->transform(gctx).linear();
  }

 private:
  std::shared_ptr<PlaneSurface> m_upSurface;
};
}  // namespace Acts