ReferenceTrajectory.h

Go to the documentation of this file.

#ifndef Alignment_ReferenceTrajectories_ReferenceTrajectory_H
#define Alignment_ReferenceTrajectories_ReferenceTrajectory_H

#include "Alignment/ReferenceTrajectories/interface/ReferenceTrajectoryBase.h"
#include "TrackingTools/TransientTrackingRecHit/interface/TransientTrackingRecHit.h"
#include "DataFormats/TrajectorySeed/interface/PropagationDirection.h"
#include "TrackingTools/TrajectoryState/interface/SurfaceSideDefinition.h"
#include "Alignment/ReferenceTrajectories/interface/GblTrajectory.h"

#include <TMatrixDSym.h>
#include <TMatrixD.h>
#include <TVectorD.h>

class TrajectoryStateOnSurface;
class MagneticField;
class MaterialEffectsUpdator;
class Plane;
class BeamSpotTransientTrackingRecHit;

namespace reco { class BeamSpot; }

class ReferenceTrajectory : public ReferenceTrajectoryBase
{

public:

  typedef SurfaceSideDefinition::SurfaceSide SurfaceSide;

  ReferenceTrajectory(const TrajectoryStateOnSurface& referenceTsos,
                      const TransientTrackingRecHit::ConstRecHitContainer& recHits,
                      const MagneticField* magField,
                      const reco::BeamSpot& beamSpot,
                      const ReferenceTrajectoryBase::Config& config);

  virtual ~ReferenceTrajectory() {}

  virtual ReferenceTrajectory* clone() const { return new ReferenceTrajectory(*this); }

protected:

  // ReferenceTrajectory(unsigned int nPar, unsigned int nHits, MaterialEffects materialEffects);
  ReferenceTrajectory(unsigned int nPar, unsigned int nHits,
              const ReferenceTrajectoryBase::Config& config);

  virtual bool construct(const TrajectoryStateOnSurface &referenceTsos, 
             const TransientTrackingRecHit::ConstRecHitContainer &recHits,
             const MagneticField *magField,
             const reco::BeamSpot &beamSpot);

  MaterialEffectsUpdator* createUpdator(MaterialEffects materialEffects, double mass) const;

  virtual bool propagate(const Plane &previousSurface, const TrajectoryStateOnSurface &previousTsos,
             const Plane &newSurface, TrajectoryStateOnSurface &newTsos, AlgebraicMatrix &newJacobian, 
             AlgebraicMatrix &newCurvlinJacobian, double &nextStep,
             const MagneticField *magField) const;
  
  virtual void fillMeasurementAndError(const TransientTrackingRecHit::ConstRecHitPointer &hitPtr,
                       unsigned int iRow,
                       const TrajectoryStateOnSurface &updatedTsos);

  virtual void fillDerivatives(const AlgebraicMatrix &projection,
                   const AlgebraicMatrix &fullJacobian, unsigned int iRow);

  virtual void fillTrajectoryPositions(const AlgebraicMatrix &projection, 
                       const AlgebraicVector &mixedLocalParams, 
                       unsigned int iRow);

  virtual bool addMaterialEffectsCov(const std::vector<AlgebraicMatrix> &allJacobians, 
                     const std::vector<AlgebraicMatrix> &allProjections,
                     const std::vector<AlgebraicSymMatrix> &allCurvChanges,
                     const std::vector<AlgebraicSymMatrix> &allDeltaParaCovs);
                     
  virtual bool addMaterialEffectsBp (const std::vector<AlgebraicMatrix> &allJacobians, 
                     const std::vector<AlgebraicMatrix> &allProjections,
                     const std::vector<AlgebraicSymMatrix> &allCurvChanges,
                     const std::vector<AlgebraicSymMatrix> &allDeltaParaCovs,
                     const std::vector<AlgebraicMatrix> &allLocalToCurv);
                     
  virtual bool addMaterialEffectsBrl(const std::vector<AlgebraicMatrix> &allJacobians, 
                     const std::vector<AlgebraicMatrix> &allProjections,
                     const std::vector<AlgebraicSymMatrix> &allCurvChanges,
                     const std::vector<AlgebraicSymMatrix> &allDeltaParaCovs,
                     const std::vector<AlgebraicMatrix> &allLocalToCurv,
                     const GlobalTrajectoryParameters &gtp);
  virtual bool addMaterialEffectsBrl(const std::vector<AlgebraicMatrix> &allProjections,
                     const std::vector<AlgebraicSymMatrix> &allDeltaParaCovs,
                     const std::vector<AlgebraicMatrix> &allLocalToCurv,
                     const std::vector<double> &allSteps,
                     const GlobalTrajectoryParameters &gtp,   
                     const double minStep = 1.0);
  
  virtual bool addMaterialEffectsLocalGbl(const std::vector<AlgebraicMatrix> &allJacobians,
                                     const std::vector<AlgebraicMatrix> &allProjections,
                                     const std::vector<AlgebraicSymMatrix> &allCurvatureChanges,
                                     const std::vector<AlgebraicSymMatrix> &allDeltaParameterCovs);

  virtual bool addMaterialEffectsCurvlinGbl(const std::vector<AlgebraicMatrix> &allJacobians,
                                     const std::vector<AlgebraicMatrix> &allProjections,
                                     const std::vector<AlgebraicSymMatrix> &allCurvChanges,
                                     const std::vector<AlgebraicSymMatrix> &allDeltaParaCovs,
                                     const std::vector<AlgebraicMatrix> &allLocalToCurv);
          
  inline SurfaceSide surfaceSide(const PropagationDirection dir) const
  {
    return ( dir == alongMomentum ) ?
      SurfaceSideDefinition::beforeSurface :
      SurfaceSideDefinition::afterSurface;
  }

  AlgebraicMatrix
    getHitProjectionMatrix(const TransientTrackingRecHit::ConstRecHitPointer &recHit) const;

  template <unsigned int N>
    AlgebraicMatrix
    getHitProjectionMatrixT(const TransientTrackingRecHit::ConstRecHitPointer &recHit) const;
private:
  void clhep2root(const AlgebraicVector& in, TVectorD& out);
  void clhep2root(const AlgebraicMatrix& in, TMatrixD& out);
  void clhep2root(const AlgebraicSymMatrix& in, TMatrixDSym& out);

  const double mass_;
  const MaterialEffects materialEffects_;
  const PropagationDirection propDir_;
  const bool useBeamSpot_;
  const bool includeAPEs_;
  const bool allowZeroMaterial_;
};

#endif