ThirdHitPrediction.h

Go to the documentation of this file.

#ifndef _ThirdHitPrediction_h_
#define _ThirdHitPrediction_h_
 
#include "RecoTracker/TkMSParametrization/interface/PixelRecoRange.h"
#include "RecoTracker/TkMSParametrization/interface/PixelRecoLineRZ.h"
#include "RecoTracker/TkTrackingRegions/interface/TkTrackingRegionsMargin.h"
#include "RecoTracker/TkTrackingRegions/interface/TrackingRegion.h"
 
#include "DataFormats/GeometryVector/interface/GlobalTag.h"
#include "DataFormats/GeometryVector/interface/Vector2DBase.h"
typedef Vector2DBase<float, GlobalTag> Global2DVector;
 
#include "DataFormats/GeometryVector/interface/GlobalPoint.h"
#include "DataFormats/GeometryVector/interface/GlobalVector.h"
 
class DetLayer;
class OrderedHitPair;
class TrackingRecHit;
 
class TransientTrackingRecHitBuilder;
 
#include "FWCore/Framework/interface/EventSetup.h"
#include "FWCore/Framework/interface/ESHandle.h"
 
#include <vector>
#include <utility>
 
class ThirdHitPrediction {
public:
  typedef PixelRecoRange<float> Range;
  typedef TkTrackingRegionsMargin<float> Margin;
 
  ThirdHitPrediction(const TrackingRegion& region,
                     GlobalPoint inner,
                     GlobalPoint outer,
                     const edm::EventSetup& es,
                     double nSigMultipleScattering,
                     double maxAngleRatio,
                     std::string builderName);
  ~ThirdHitPrediction();
 
  void getRanges(const DetLayer* layer, float phi[], float rz[]);
  void getRanges(float rORz, float phi[], float rz[]);
 
  bool isCompatibleWithMultipleScattering(GlobalPoint g3,
                                          const std::vector<const TrackingRecHit*>& h,
                                          std::vector<GlobalVector>& localDirs,
                                          const edm::EventSetup& es);
 
private:
  void initLayer(const DetLayer* layer);
 
  void printOut(char* text);
 
  void invertCircle(Global2DVector& c, float& r);
  void invertPoint(Global2DVector& p);
 
  std::pair<float, float> findMinimalCircles(float r);
  std::pair<float, float> findTouchingCircles(float r);
 
  std::pair<float, float> findArcIntersection(std::pair<float, float> a, std::pair<float, float> b, bool& keep);
 
  void fitParabola(const float x[3], const float y[3], float par[3]);
  void findRectangle(const float x[3], const float y[3], const float par[3], float phi[2], float z[2]);
 
  float areaParallelogram(const Global2DVector& a, const Global2DVector& b);
  float angleRatio(const Global2DVector& p3, const Global2DVector& c);
 
  void spinCloser(float phi[3]);
 
  void calculateRangesBarrel(float r3, float phi[2], float z[2], bool keep);
  void calculateRangesForward(float z3, float phi[2], float r[2], bool keep);
  void calculateRanges(float rz3, float phi[2], float rz[2]);
 
  bool theBarrel, theForward;
  Range theDetRange;
  Margin theTolerance;
  PixelRecoLineRZ theLine;
 
  const DetLayer* theLayer;
 
  const TransientTrackingRecHitBuilder* theTTRecHitBuilder;
 
  // Data
  float Bz, r0, rm;
  GlobalPoint g1, g2;
  Global2DVector c0, p1, p2, dif;
  std::pair<float, float> arc_0m;
 
  bool keep;
 
  double nSigma;
  double maxRatio;
};
#endif