---

BasicSingleTrajectoryState.h

Go to the documentation of this file.

#ifndef BasicSingleTrajectoryState_H
#define BasicSingleTrajectoryState_H

#include "TrackingTools/TrajectoryState/interface/BasicTrajectoryState.h"
#include "TrackingTools/TrajectoryState/interface/FreeTrajectoryState.h"
#include "TrackingTools/TrajectoryParametrization/interface/LocalTrajectoryParameters.h"
#include "TrackingTools/TrajectoryParametrization/interface/LocalTrajectoryError.h"

#include "DataFormats/GeometrySurface/interface/ReferenceCounted.h"

#include "DataFormats/GeometryCommonDetAlgo/interface/DeepCopyPointer.h"
#include "DataFormats/GeometrySurface/interface/Surface.h"
#include "TrackingTools/TrajectoryParametrization/interface/TrajectoryStateExceptions.h"

#include <iostream>

class MagneticField;

class BasicSingleTrajectoryState : public BasicTrajectoryState {
public:

  BasicSingleTrajectoryState( const FreeTrajectoryState& fts,
                              const Surface& aSurface,
                              const SurfaceSide side = atCenterOfSurface);
  BasicSingleTrajectoryState( const GlobalTrajectoryParameters& par,
                              const Surface& aSurface,
                              const SurfaceSide side = atCenterOfSurface);
  BasicSingleTrajectoryState( const GlobalTrajectoryParameters& par,
                              const CartesianTrajectoryError& err,
                              const Surface& aSurface,
                              const SurfaceSide side = atCenterOfSurface);
  BasicSingleTrajectoryState( const GlobalTrajectoryParameters& par,
                              const CurvilinearTrajectoryError& err,
                              const Surface& aSurface,
                              const SurfaceSide side = atCenterOfSurface,
                              double weight = 1.);
  BasicSingleTrajectoryState( const GlobalTrajectoryParameters& par,
                              const CurvilinearTrajectoryError& err,
                              const Surface& aSurface,
                              double weight);
  BasicSingleTrajectoryState( const LocalTrajectoryParameters& par,
                              const Surface& aSurface,
                              const MagneticField* field,
                              const SurfaceSide side = atCenterOfSurface);
  BasicSingleTrajectoryState( const LocalTrajectoryParameters& par,
                              const LocalTrajectoryError& err,
                              const Surface& aSurface,
                              const MagneticField* field,
                              const SurfaceSide side = atCenterOfSurface,
                              double weight = 1.);
  BasicSingleTrajectoryState( const LocalTrajectoryParameters& par,
                              const LocalTrajectoryError& err,
                              const Surface& aSurface,
                              const MagneticField* field,
                              double weight);

  BasicSingleTrajectoryState(const Surface& aSurface);

  virtual ~BasicSingleTrajectoryState();

  bool isValid() const {
    return theFreeState || theLocalParametersValid;
  }

  bool hasError() const {
    return (theFreeState && theFreeState->hasError()) || theLocalErrorValid;
  }

// access global parameters/errors
  const GlobalTrajectoryParameters& globalParameters() const {
    return freeTrajectoryState(false)->parameters();
  }
  GlobalPoint globalPosition() const {
    return freeTrajectoryState(false)->position();
  }
  GlobalVector globalMomentum() const {
    return freeTrajectoryState(false)->momentum();
  }
  GlobalVector globalDirection() const {
    return freeTrajectoryState(false)->momentum().unit();
  }  
  TrackCharge charge() const {
    return freeTrajectoryState(false)->charge();
  }
  double signedInverseMomentum() const {
    return freeTrajectoryState(false)->signedInverseMomentum();
  }
  double transverseCurvature() const {
    return freeTrajectoryState(false)->transverseCurvature();
  }
  const CartesianTrajectoryError& cartesianError() const {
    if(!hasError()) throw TrajectoryStateException(
     "TrajectoryStateOnSurface: attempt to access cartesian errors when none available");
    return freeTrajectoryState()->cartesianError();
  }
  const CurvilinearTrajectoryError& curvilinearError() const {
    if(!hasError()) throw TrajectoryStateException(
     "TrajectoryStateOnSurface: attempt to access curvilinear errors when none available");
    return freeTrajectoryState()->curvilinearError();
  }
  FreeTrajectoryState* freeTrajectoryState(bool withErrors = true) const {
    if(!isValid()) throw TrajectoryStateException(
      "TrajectoryStateOnSurface is invalid and cannot return any parameters");
    checkGlobalParameters();
    //if(hasError()) { // let's start like this to see if we alloc less
    if(withErrors && hasError()) { // this is the right thing
      checkCartesianError();
      checkCurvilinError();
    }
    return &(*theFreeState);
  }
  
  const MagneticField *magneticField() const { return theField; }

// access local parameters/errors
  const LocalTrajectoryParameters& localParameters() const {
    if (!isValid()) throw TrajectoryStateException(
      "TrajectoryStateOnSurface is invalid and cannot return any parameters");
    if (!theLocalParametersValid)
      createLocalParameters();
    return theLocalParameters;
  }
  LocalPoint localPosition() const {
    return localParameters().position();
  }
  LocalVector localMomentum() const {
    return localParameters().momentum();
  }
  LocalVector localDirection() const {
    return localMomentum().unit();
  }
  const LocalTrajectoryError& localError() const {
    if (!hasError()) throw TrajectoryStateException(
      "TrajectoryStateOnSurface: attempt to access errors when none available");
    if (!theLocalErrorValid)
      createLocalError();
    return theLocalError;
  }

  const Surface& surface() const {
    return *theSurfaceP;
  }

  virtual double weight() const {return theWeight;} 

  void rescaleError(double factor) {
    if (!hasError()) throw TrajectoryStateException(
      "TrajectoryStateOnSurface: attempt to access errors when none available");
    if (theLocalErrorValid) theLocalError *= (factor*factor);
    if (theFreeState)
      theFreeState->rescaleError(factor);
  }

  BasicSingleTrajectoryState* clone() const {
    return new BasicSingleTrajectoryState(*this);
  }

  virtual SurfaceSide surfaceSide() const {
    return theSurfaceSide;
  }

private:

// create global parameters and errors from local
  void checkGlobalParameters() const;
  void checkCurvilinError() const;
  void checkCartesianError() const;

// create local parameters and errors from global
  void createLocalParameters() const;
  // create local errors from global
  void createLocalError() const;
  void createLocalErrorFromCartesianError() const;
  void createLocalErrorFromCurvilinearError() const;

private:

  mutable DeepCopyPointer<FreeTrajectoryState> theFreeState;

  mutable bool theGlobalParamsUp2Date;
  mutable bool theCartesianErrorUp2Date;
  mutable bool theCurvilinErrorUp2Date;

  mutable LocalTrajectoryParameters theLocalParameters;
  mutable LocalTrajectoryError      theLocalError;
  mutable bool                      theLocalParametersValid;
  mutable bool                      theLocalErrorValid;

  ConstReferenceCountingPointer<Surface> theSurfaceP;
  const SurfaceSide theSurfaceSide;
  double theWeight;
  const MagneticField* theField;

};

#endif

---