SmartPropagator.h

Go to the documentation of this file.

#ifndef GeomPropagators_SmartPropagator_H
#define GeomPropagators_SmartPropagator_H

/* Collaborating Class Declarations */
#include "TrackingTools/TrajectoryState/interface/FreeTrajectoryState.h"
#include "TrackingTools/TrajectoryState/interface/TrajectoryStateOnSurface.h"
#include "TrackingTools/GeomPropagators/interface/Propagator.h"
#include "MagneticField/Engine/interface/MagneticField.h"
#include "DataFormats/GeometrySurface/interface/ReferenceCounted.h"
#include "DataFormats/TrajectorySeed/interface/PropagationDirection.h"

class Cylinder;
class Plane;


/* Class SmartPropagator Interface */

class SmartPropagator GCC11_FINAL : public Propagator {

  public:

    /* Constructor */ 
    SmartPropagator(const Propagator* aTkProp, const Propagator* aGenProp, const MagneticField* field,
        PropagationDirection dir = alongMomentum, float epsilon = 5) ;

    SmartPropagator(const Propagator& aTkProp, const Propagator& aGenProp,const MagneticField* field,
        PropagationDirection dir = alongMomentum, float epsilon = 5) ;

    SmartPropagator( const SmartPropagator& );

    virtual ~SmartPropagator() ;

    virtual SmartPropagator* clone() const {
      return new SmartPropagator(getTkPropagator(),getGenPropagator(),magneticField());
    }

    void setPropagationDirection (PropagationDirection dir) const
    {
      Propagator::setPropagationDirection (dir);
      getTkPropagator()->setPropagationDirection(dir);
      getGenPropagator()->setPropagationDirection(dir);
    }


    /* Operations as propagator*/ 
    TrajectoryStateOnSurface propagate(const FreeTrajectoryState& fts, 
                                       const Surface& surface) const;

    TrajectoryStateOnSurface propagate(const TrajectoryStateOnSurface& tsos, 
                                       const Surface& surface) const {
      return Propagator::propagate(tsos,surface);
    }

    TrajectoryStateOnSurface propagate(const FreeTrajectoryState& fts,
                                       const Plane& plane) const;

    TrajectoryStateOnSurface propagate(const TrajectoryStateOnSurface& tsos,
                                       const Plane& plane) const {
      return Propagator::propagate(tsos, plane);
    }

    TrajectoryStateOnSurface propagate(const FreeTrajectoryState& fts, 
                                       const Cylinder& cylinder) const;

    TrajectoryStateOnSurface propagate(const TrajectoryStateOnSurface& tsos, 
                                       const Cylinder& cylinder) const {
      return Propagator::propagate(tsos, cylinder);
    }

    std::pair<TrajectoryStateOnSurface,double> 
      propagateWithPath(const FreeTrajectoryState& fts, 
                        const Surface& surface) const {
        return Propagator::propagateWithPath(fts,surface);
      }

    std::pair<TrajectoryStateOnSurface,double> 
      propagateWithPath(const TrajectoryStateOnSurface& tsos, 
                        const Surface& surface) const {
        return Propagator::propagateWithPath(tsos,surface);
      }

    std::pair<TrajectoryStateOnSurface,double> 
      propagateWithPath(const FreeTrajectoryState& fts, 
                        const Plane& plane) const;

    std::pair<TrajectoryStateOnSurface,double> 
      propagateWithPath(const TrajectoryStateOnSurface& tsos, 
                        const Plane& plane) const {
        return Propagator::propagateWithPath(tsos, plane);
      }

    std::pair<TrajectoryStateOnSurface,double> 
      propagateWithPath(const FreeTrajectoryState& fts, 
                        const Cylinder& cylinder) const;

    std::pair<TrajectoryStateOnSurface,double> 
      propagateWithPath(const TrajectoryStateOnSurface& tsos, 
                        const Cylinder& cylinder) const {
        return Propagator::propagateWithPath(tsos, cylinder);
      }

    bool insideTkVol(const FreeTrajectoryState& fts) const ;
    bool insideTkVol(const Surface& surface) const ;
    bool insideTkVol(const Cylinder& cylin)  const ;
    bool insideTkVol(const Plane& plane)  const ;

    const Propagator* getTkPropagator() const ;
    const Propagator* getGenPropagator() const ;
    virtual const MagneticField* magneticField() const {return theField;}

  private:
    void initTkVolume(float epsilon);

    Propagator* theTkProp;
    Propagator* theGenProp;
    const MagneticField* theField;
    ReferenceCountingPointer<Cylinder> theTkVolume;

  protected:

};

#endif // SMARTPROPAGATOR_H