BasicTrajectoryState.h

Go to the documentation of this file.

#ifndef BasicTrajectoryState_H
#define BasicTrajectoryState_H

#include "TrackingTools/TrajectoryState/interface/ProxyBase11.h"

#include "TrackingTools/TrajectoryParametrization/interface/LocalTrajectoryParameters.h"
#include "TrackingTools/TrajectoryParametrization/interface/LocalTrajectoryError.h"
#include "TrackingTools/TrajectoryParametrization/interface/GlobalTrajectoryParameters.h"
#include "TrackingTools/TrajectoryParametrization/interface/CartesianTrajectoryError.h"
#include "TrackingTools/TrajectoryParametrization/interface/CurvilinearTrajectoryError.h"
#include "TrackingTools/TrajectoryState/interface/SurfaceSideDefinition.h"

#include <vector>


#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 TrajectoryStateOnSurface;


#ifdef DO_BTSCount
class BTSCount {
public:
  BTSCount(){}
  virtual ~BTSCount();
  BTSCount(BTSCount const &){} 

  static unsigned int  maxReferences;
  static unsigned long long  aveReferences;
  static unsigned long long  toteReferences;

  void addReference() const { ++referenceCount_ ; referenceMax_ = std::max(referenceMax_, referenceCount_); }
  void removeReference() const { 
    if( 0 == --referenceCount_ ) {
      delete const_cast<BTSCount*>(this);
    }
  }
  
  unsigned int references() const {return referenceCount_;}
private :
  mutable unsigned int referenceCount_=0;
  mutable unsigned int referenceMax_ =0;
};
#endif

class BasicTrajectoryState {
  public:

  typedef BasicTrajectoryState                              BTSOS;
  typedef ProxyBase11<BTSOS>                                Proxy;
  typedef Proxy::pointer                           pointer;
  typedef SurfaceSideDefinition::SurfaceSide SurfaceSide;
  typedef Surface SurfaceType;

public:

  // default constructor : to make root happy
  BasicTrajectoryState() : theValid(false), theWeight(0){}

  explicit BasicTrajectoryState(const SurfaceType& aSurface);

  virtual ~BasicTrajectoryState();

  virtual pointer clone() const=0;

  template<typename T, typename... Args>
  static std::shared_ptr<BTSOS> build(Args && ...args){ return std::make_shared<T>(std::forward<Args>(args)...);}

  template<typename T, typename... Args>
  static std::shared_ptr<BTSOS> churn(Args && ...args){ return std::allocate_shared<T>(churn_allocator<T>(),std::forward<Args>(args)...);}



  BasicTrajectoryState( const FreeTrajectoryState& fts,
            const SurfaceType& aSurface,
            const SurfaceSide side = SurfaceSideDefinition::atCenterOfSurface):
    theFreeState(fts),
    theLocalError(InvalidError()),
    theLocalParameters(),
    theLocalParametersValid(false),
    theValid(true),
    theSurfaceSide(side),
    theSurfaceP( &aSurface),
    theWeight(1.)
    {}



  explicit BasicTrajectoryState( const FreeTrajectoryState& fts):
    theFreeState(fts),
    theLocalError(InvalidError()),
    theLocalParameters(),
    theLocalParametersValid(false),
    theValid(true),
    theWeight(1.)
    {}




  BasicTrajectoryState( const LocalTrajectoryParameters& par,
            const LocalTrajectoryError& err,
            const SurfaceType& aSurface,
            const MagneticField* field,
            const SurfaceSide side=SurfaceSideDefinition::atCenterOfSurface);


  BasicTrajectoryState( const LocalTrajectoryParameters& par,
            const SurfaceType& aSurface,
            const MagneticField* field,
            const SurfaceSide side = SurfaceSideDefinition::atCenterOfSurface) :
    BasicTrajectoryState(par, InvalidError(), aSurface, field, side){}




  BasicTrajectoryState( const GlobalTrajectoryParameters& par,
            const CartesianTrajectoryError& err,
            const SurfaceType& aSurface,
            const SurfaceSide side = SurfaceSideDefinition::atCenterOfSurface):
    theFreeState(par, err),
    theLocalError(InvalidError()),
    theLocalParameters(),
    theLocalParametersValid(false),
    theValid(true),
    theSurfaceSide(side),
    theSurfaceP( &aSurface),
    theWeight(1.)
    {}


  BasicTrajectoryState( const GlobalTrajectoryParameters& par,
            const CurvilinearTrajectoryError& err,
            const SurfaceType& aSurface,
            const SurfaceSide side = SurfaceSideDefinition::atCenterOfSurface) :
  theFreeState(par, err),
  theLocalError(InvalidError()),
  theLocalParameters(),
  theLocalParametersValid(false),
  theValid(true),
  theSurfaceSide(side), 
  theSurfaceP( &aSurface), 
  theWeight(1.)
  {}


  BasicTrajectoryState( const GlobalTrajectoryParameters& par,
            const SurfaceType& aSurface,
            const SurfaceSide side = SurfaceSideDefinition::atCenterOfSurface) :
    BasicTrajectoryState(par, InvalidError(), aSurface, side){}


  // as above, with explicit weight
  template<typename... Args>
  BasicTrajectoryState(double iweight, Args && ...args) : BasicTrajectoryState(std::forward<Args>(args)...) {
    theWeight = iweight;
  }



  bool isValid() const { return theValid; }


// access global parameters/errors
  const GlobalTrajectoryParameters& globalParameters() const {
    return theFreeState.parameters();
  }
  GlobalPoint globalPosition() const {
    return theFreeState.position();
  }
  GlobalVector globalMomentum() const {
    return theFreeState.momentum();
  }
  GlobalVector globalDirection() const {
    return theFreeState.momentum().unit();
  }  
  TrackCharge charge() const {
    return theFreeState.charge();
  }
  double signedInverseMomentum() const {
    return theFreeState.signedInverseMomentum();
  }
  double transverseCurvature() const {
    return theFreeState.transverseCurvature();
  }

  const CartesianTrajectoryError cartesianError() const {
    if unlikely(!hasError()) {
    missingError(" accesing cartesian error.");
    return CartesianTrajectoryError();
      }
    return freeTrajectoryState(true)->cartesianError();
  }
  const CurvilinearTrajectoryError& curvilinearError() const {
    if unlikely(!hasError()) {
    missingError(" accesing curvilinearerror.");
    static const CurvilinearTrajectoryError crap;
    return crap;
      }
    return freeTrajectoryState(true)->curvilinearError();
  }



  FreeTrajectoryState const* freeTrajectoryState(bool withErrors=true) const {
    if unlikely(!isValid()) notValid();
    if(withErrors && hasError()) { // this is the right thing
      checkCurvilinError();
    }
    return &theFreeState;
  }

  
  const MagneticField *magneticField() const { return &theFreeState.parameters().magneticField(); }

// access local parameters/errors
  const LocalTrajectoryParameters& localParameters() const {
    if unlikely(!isValid()) notValid();
    if unlikely(!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 unlikely(!hasError()) {
    missingError(" accessing local error.");
    return theLocalError;
      }
    if unlikely(theLocalError.invalid()) createLocalError();
    return theLocalError;
  }

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

  double weight() const {return theWeight;} 

  void rescaleError(double factor);



  SurfaceSide surfaceSide() const {
    return theSurfaceSide;
  }

  bool hasError() const {
    return theFreeState.hasError() || theLocalError.valid();
  }


  virtual bool canUpdateLocalParameters() const { return true; }

  virtual void update( const LocalTrajectoryParameters& p,
                       const SurfaceType& aSurface,
                       const MagneticField* field,
                       const SurfaceSide side ) ;

  // update in place and in the very same place
  virtual void update( const LocalTrajectoryParameters& p, const SurfaceSide side ) final;
                       


  virtual void update( double weight,
               const LocalTrajectoryParameters& p,
                       const LocalTrajectoryError& err,
                       const SurfaceType& aSurface,
                       const MagneticField* field,
                       const SurfaceSide side);

  // update in place and in the very same place
 virtual void update( const LocalTrajectoryParameters& p,
                       const LocalTrajectoryError& err,
                       const SurfaceSide side) final;

 CurvilinearTrajectoryError & setCurvilinearError() {
    return theFreeState.setCurvilinearError();
 }

public:
  using Components = std::vector<TrajectoryStateOnSurface>;
  virtual Components const & components() const =0;
  virtual bool singleState() const=0;

private:

  static void notValid();

  
  void missingError(char const * where) const; // dso_internal;

  // create global errors from local
  void checkCurvilinError() const; //  dso_internal;
  
  // create local parameters and errors from global
  void createLocalParameters() const;
  // create local errors from global
  void createLocalError() const;
  void createLocalErrorFromCurvilinearError() const  dso_internal;
  
private:

  mutable FreeTrajectoryState theFreeState;

  mutable LocalTrajectoryError      theLocalError;
  mutable LocalTrajectoryParameters theLocalParameters;

  mutable bool theLocalParametersValid;
  mutable bool theValid;

 
  SurfaceSide theSurfaceSide;
  ConstReferenceCountingPointer<SurfaceType> theSurfaceP;

  double theWeight=0.;
};

#endif