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 <Eigen/Dense>
 
#include "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};
  };
 
  ~ReferenceTrajectoryBase() override {}
 
  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>, Eigen::MatrixXd> >& gblInput() { return theGblInput; }
 
  const Eigen::MatrixXd& gblExtDerivatives() const { return theGblExtDerivatives; }
 
  const Eigen::VectorXd& gblExtMeasurements() const { return theGblExtMeasurements; }
 
  const Eigen::VectorXd& 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>, Eigen::MatrixXd> > theGblInput;
  int theNomField;
  // CHK GBL TBD:       virtual (mass) measurement
  Eigen::MatrixXd theGblExtDerivatives;
  Eigen::VectorXd theGblExtMeasurements;
  Eigen::VectorXd theGblExtPrecisions;
 
  static constexpr unsigned int nMeasPerHit{2};
};
 
#endif  // REFERENCE_TRAJECTORY_BASE_H