TrajectoryStateOnSurface.h

Go to the documentation of this file.

#ifndef TrajectoryStateOnSurface_H
#define TrajectoryStateOnSurface_H
 
#include "TrackingTools/TrajectoryState/interface/BasicTrajectoryState.h"
#include "TrackingTools/TrajectoryState/interface/SurfaceSideDefinition.h"
#include "TrackingTools/TrajectoryState/interface/BasicSingleTrajectoryState.h"
 
#include <iosfwd>
 
class TrajectoryStateOnSurface : private BasicTrajectoryState::Proxy {
  typedef BasicTrajectoryState BTSOS;
  typedef BasicTrajectoryState::SurfaceType SurfaceType;
  typedef BasicTrajectoryState::SurfaceSide SurfaceSide;
  typedef BasicTrajectoryState::Proxy Base;
 
public:
  // construct
  TrajectoryStateOnSurface() {}
  explicit TrajectoryStateOnSurface(Base::pointer p) : Base(p) {}
  explicit TrajectoryStateOnSurface(BasicTrajectoryState* p) : Base(p) {}
  explicit TrajectoryStateOnSurface(BasicSingleTrajectoryState* p) : Base(p) {}
 
  ~TrajectoryStateOnSurface() {}
 
  TrajectoryStateOnSurface(TrajectoryStateOnSurface& rh) noexcept : Base(rh) {}
 
  TrajectoryStateOnSurface(TrajectoryStateOnSurface const& rh) noexcept : Base(rh) {}
 
  TrajectoryStateOnSurface(TrajectoryStateOnSurface&& rh) noexcept : Base(std::forward<Base>(rh)) {}
 
  TrajectoryStateOnSurface& operator=(TrajectoryStateOnSurface&& rh) noexcept {
    Base::swap(rh);
    return *this;
  }
 
  TrajectoryStateOnSurface& operator=(TrajectoryStateOnSurface const& rh) noexcept {
    Base::operator=(rh);
    return *this;
  }
 
  template <typename... Args>
  explicit TrajectoryStateOnSurface(Args&&... args)
      : Base(BTSOS::churn<BasicSingleTrajectoryState>(std::forward<Args>(args)...)) {}
 
  void swap(TrajectoryStateOnSurface& rh) noexcept { Base::swap(rh); }
 
  bool isValid() const { return Base::isValid() && data().isValid(); }
 
  bool hasError() const { return data().hasError(); }
 
  FreeTrajectoryState const* freeState(bool withErrors = true) const { return data().freeTrajectoryState(); }
 
  FreeTrajectoryState const* freeTrajectoryState(bool withErrors = true) const { return freeState(); }
 
  const MagneticField* magneticField() const { return data().magneticField(); }
 
  const GlobalTrajectoryParameters& globalParameters() const { return data().globalParameters(); }
  GlobalPoint globalPosition() const { return data().globalPosition(); }
  GlobalVector globalMomentum() const { return data().globalMomentum(); }
  GlobalVector globalDirection() const { return data().globalDirection(); }
  TrackCharge charge() const { return data().charge(); }
  double signedInverseMomentum() const { return data().signedInverseMomentum(); }
  double transverseCurvature() const { return data().transverseCurvature(); }
  const CartesianTrajectoryError cartesianError() const { return data().cartesianError(); }
  const CurvilinearTrajectoryError& curvilinearError() const { return data().curvilinearError(); }
  const LocalTrajectoryParameters& localParameters() const { return data().localParameters(); }
  LocalPoint localPosition() const { return data().localPosition(); }
  LocalVector localMomentum() const { return data().localMomentum(); }
  LocalVector localDirection() const { return data().localDirection(); }
  const LocalTrajectoryError& localError() const { return data().localError(); }
  const SurfaceType& surface() const { return data().surface(); }
 
  double weight() const { return data().weight(); }
 
  void rescaleError(double factor) { unsharedData().rescaleError(factor); }
 
  using Components = BasicTrajectoryState::Components;
  Components const& components() const { return data().components(); }
  bool singleState() const { return data().singleState(); }
 
  SurfaceSide surfaceSide() const { return data().surfaceSide(); }
 
  void update(const LocalTrajectoryParameters& p,
              const SurfaceType& aSurface,
              const MagneticField* field,
              SurfaceSide side = SurfaceSideDefinition::atCenterOfSurface);
 
  void update(const LocalTrajectoryParameters& p, SurfaceSide side) { unsharedData().update(p, side); }
 
  void update(const LocalTrajectoryParameters& p, const LocalTrajectoryError& err, SurfaceSide side) {
    unsharedData().update(p, err, side);
  }
 
  void update(const LocalTrajectoryParameters& p,
              const LocalTrajectoryError& err,
              const SurfaceType& aSurface,
              const MagneticField* field,
              SurfaceSide side = SurfaceSideDefinition::atCenterOfSurface);
 
  CurvilinearTrajectoryError& setCurvilinearError() { return sharedData().setCurvilinearError(); }
};
 
inline void swap(TrajectoryStateOnSurface& rh, TrajectoryStateOnSurface& lh) {
  // use base swap
  rh.swap(lh);
}
 
std::ostream& operator<<(std::ostream& os, const TrajectoryStateOnSurface& tsos);
#endif