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() {}
#ifndef CMS_NOCXX11
  explicit TrajectoryStateOnSurface( Base::pointer p) : Base(p) {}
#endif
  explicit TrajectoryStateOnSurface( BasicTrajectoryState* p) : Base(p) {}
  explicit TrajectoryStateOnSurface( BasicSingleTrajectoryState* p) : Base(p) {}

  ~TrajectoryStateOnSurface() {}

#ifndef CMS_NOCXX11

 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)...)){}

#endif

  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);
  }

  std::vector<TrajectoryStateOnSurface> components() const {
    return data().components();
  }
  /*
  std::vector<TrajectoryStateOnSurface> components() const {
    std::vector<BasicTrajectoryState::RCPtr> c( data().components());
    std::vector<TrajectoryStateOnSurface> result; 
    result.reserve(c.size());
    for (std::vector<BasicTrajectoryState::RCPtr>::iterator i=c.begin();
     i != c.end(); i++) result.push_back(&(**i));
    return result;
  }
  */

  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 GlobalTrajectoryParameters& par,
           const SurfaceType& aSurface,
           SurfaceSide side) { unsharedData().update(par, aSurface, side);}
  
  void update( const GlobalTrajectoryParameters& par,
               const CurvilinearTrajectoryError& err,
               const SurfaceType& aSurface,
               SurfaceSide side) { unsharedData().update(par, err, aSurface, side);}
  */

  void update(const LocalTrajectoryParameters& p,
          const LocalTrajectoryError& err,
          const SurfaceType& aSurface,
          const MagneticField* field,
          SurfaceSide side = SurfaceSideDefinition::atCenterOfSurface);
  /*
#ifndef CMS_NOCXX11
  template<typename... Args>
  void update(Args && ...args) {
    if (data().canUpdateLocalParameters()) {
      unsharedData().update(std::forward<Args>(args)...);
    } else {
      *this = TrajectoryStateOnSurface(std::forward<Args>(args)...);
    }
  }
#endif
  */

  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