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