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, 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