ReferenceTrajectoryBase.h

Go to the documentation of this file.

#ifndef Alignment_ReferenceTrajectories_ReferenceTrajectoryBase_H
#define Alignment_ReferenceTrajectories_ReferenceTrajectoryBase_H

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

// for AlgebraicVector, -Matrix and -SymMatrix:
#include "DataFormats/CLHEP/interface/AlgebraicObjects.h"
#include "TrackingTools/TransientTrackingRecHit/interface/TransientTrackingRecHit.h"
#include "TrackingTools/TrajectoryState/interface/TrajectoryStateOnSurface.h"
#include "TrackingTools/TrajectoryParametrization/interface/LocalTrajectoryError.h"

#include <vector>

#include "Alignment/ReferenceTrajectories/interface/GblTrajectory.h"


class ReferenceTrajectoryBase : public ReferenceCounted
{

public:

  typedef ReferenceCountingPointer<ReferenceTrajectoryBase> ReferenceTrajectoryPtr;

  enum MaterialEffects { none, multipleScattering, energyLoss, combined, 
             breakPoints, brokenLinesCoarse, brokenLinesFine, localGBL, curvlinGBL };

  struct Config {
    Config(MaterialEffects matEff, PropagationDirection direction,
       double m = -std::numeric_limits<double>::infinity(),
       double est = -std::numeric_limits<double>::infinity()) :
      materialEffects(matEff),
      propDir(direction),
      mass(m),
      momentumEstimate(est)
    {}

    MaterialEffects materialEffects;
    PropagationDirection propDir;
    double mass;
    double momentumEstimate;
    bool useBeamSpot{false};
    bool hitsAreReverse{false};
    bool useRefittedState{false};
    bool constructTsosWithErrors{false};
    bool includeAPEs{false};
    bool allowZeroMaterial{false};
  };

  virtual ~ReferenceTrajectoryBase() {}

  bool isValid() { return theValidityFlag; }

  const AlgebraicVector& measurements() const { return theMeasurements; }

  const AlgebraicSymMatrix& measurementErrors() const { return theMeasurementsCov; }
  
  const AlgebraicVector& trajectoryPositions() const { return theTrajectoryPositions; }

  const AlgebraicSymMatrix& trajectoryPositionErrors() const { return theTrajectoryPositionCov; }

  const AlgebraicMatrix& derivatives() const { return theDerivatives; }

  const AlgebraicMatrix& trajectoryToCurv() const { return theInnerTrajectoryToCurvilinear; }
  const AlgebraicMatrix& localToTrajectory() const { return theInnerLocalToTrajectory; }  
  
  std::vector<std::pair<std::vector<gbl::GblPoint>, TMatrixD> >& gblInput() { return theGblInput; }

  const TMatrixD& gblExtDerivatives() const { return theGblExtDerivatives; }

  const TVectorD& gblExtMeasurements() const { return theGblExtMeasurements; }

  const TVectorD& gblExtPrecisions() const { return theGblExtPrecisions; }
  

  const AlgebraicVector& parameters() const { return theParameters; }

  inline bool parameterErrorsAvailable() const { return theParamCovFlag; }

  inline void setParameterErrors( const AlgebraicSymMatrix& error ) { theParameterCov = error; theParamCovFlag = true; }
  
  inline const AlgebraicSymMatrix& parameterErrors() const { return theParameterCov; }

  const std::vector<TrajectoryStateOnSurface>& trajectoryStates() const { return theTsosVec; }

  const TransientTrackingRecHit::ConstRecHitContainer& recHits() const { return theRecHits; }

  inline unsigned int numberOfHits() const { return theNumberOfHits; }
  inline unsigned int numberOfPar() const { return theNumberOfPars; }
  inline unsigned int numberOfVirtualMeas() const { return theNumberOfVirtualMeas; }  
  inline unsigned int numberOfVirtualPar() const { return theNumberOfVirtualPars; }  
  inline unsigned int numberOfHitMeas() const { return theNumberOfHits * nMeasPerHit; } 
  inline int nominalField() const { return theNomField; }
       
  virtual ReferenceTrajectoryBase* clone() const = 0;

protected:

  explicit ReferenceTrajectoryBase(unsigned int nPar, unsigned int nHits,
                   unsigned int nVirtualPar, unsigned int nVirtualMeas);

  unsigned int numberOfUsedRecHits(const TransientTrackingRecHit::ConstRecHitContainer &recHits) const;
  bool useRecHit(const TransientTrackingRecHit::ConstRecHitPointer& hitPtr) const;

  bool theValidityFlag;
  bool theParamCovFlag;

  unsigned int theNumberOfHits;   // number of (measurements from) hits
  unsigned int theNumberOfPars;   // number of (track) parameters
  unsigned int theNumberOfVirtualMeas; // number of virtual measurements
  unsigned int theNumberOfVirtualPars; // number of parameters for virtual measurements
      
  std::vector<TrajectoryStateOnSurface> theTsosVec;
  TransientTrackingRecHit::ConstRecHitContainer theRecHits;

  AlgebraicVector     theMeasurements;
  AlgebraicSymMatrix  theMeasurementsCov;

  AlgebraicVector     theTrajectoryPositions;
  AlgebraicSymMatrix  theTrajectoryPositionCov;

  AlgebraicVector     theParameters;
  AlgebraicSymMatrix  theParameterCov;

  AlgebraicMatrix     theDerivatives;

// CHK for beamspot   transformation trajectory parameter to curvilinear at refTSos
  AlgebraicMatrix     theInnerTrajectoryToCurvilinear;  
// CHK for TwoBodyD.  transformation local to trajectory parameter at refTsos
  AlgebraicMatrix     theInnerLocalToTrajectory;
// CHK GBL input:     list of (list of points on trajectory and transformation at inner (first) point)
  std::vector<std::pair<std::vector<gbl::GblPoint>, TMatrixD> > theGblInput;
  int                           theNomField;
// CHK GBL TBD:       virtual (mass) measurement
  TMatrixD            theGblExtDerivatives;
  TVectorD            theGblExtMeasurements;
  TVectorD            theGblExtPrecisions;    
    
  static const unsigned int nMeasPerHit = 2;
};

#endif // REFERENCE_TRAJECTORY_BASE_H