LxTBTieTracks.h

Go to the documentation of this file.

/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
 
/* 
 * File:   LxTBTieTracks.h
 * Author: tablyaz
 *
 * Created on September 1, 2016, 11:33 AM
 */
 
#ifndef LXTBTIETRACKS_H
#define LXTBTIETRACKS_H
 
#include "FairTrackParam.h"
#include "LxTBBinned.h"
#include "LxTBDefinitions.h"
 
class TClonesArray;
 
struct LxTBBinndedLayer {
  scaltype z;
  int nofXBins;
  int nofYBins;
  int nofTBins;
  int lastXBin;
  int lastYBin;
  int lastTBin;
  scaltype minX;
  scaltype maxX;
  scaltype binSizeX;
  scaltype minY;
  scaltype maxY;
  scaltype binSizeY;
  timetype minT;
  timetype maxT;
  int binSizeT;
  int timeSliceLength;
  scaltype maxDx;
  scaltype maxDy;
  timetype maxDt;
  LxTbTYXBin* tyxBins;
 
  LxTBBinndedLayer(int nofxb, int nofyb, int noftb, int bst)
    : z()
    , nofXBins(nofxb)
    , nofYBins(nofyb)
    , nofTBins(noftb)
    , lastXBin(nofxb - 1)
    , lastYBin(nofyb - 1)
    , lastTBin(noftb - 1)
    , minX()
    , maxX()
    , binSizeX()
    , minY()
    , maxY()
    , binSizeY()
    , minT(0)
    , maxT(0)
    , binSizeT(bst)
    , timeSliceLength(nofTBins * binSizeT)
    , maxDx(0)
    , maxDy(0)
    , maxDt(0)
    , tyxBins(reinterpret_cast<LxTbTYXBin*>(
        new unsigned char[noftb * sizeof(LxTbTYXBin)])) {
    for (int i = 0; i < noftb; ++i)
      new (&tyxBins[i]) LxTbTYXBin(nofXBins, nofYBins);
  }
  LxTBBinndedLayer(const LxTBBinndedLayer&) = delete;
  LxTBBinndedLayer& operator=(const LxTBBinndedLayer&) = delete;
 
  ~LxTBBinndedLayer() { delete[] reinterpret_cast<unsigned char*>(tyxBins); }
 
  void Clear() {
    for (int i = 0; i < nofTBins; ++i)
      tyxBins[i].Clear();
  }
 
  void Init() {
    binSizeX = (maxX - minX) / nofXBins;
    binSizeY = (maxY - minY) / nofYBins;
  }
 
  void SetTSBegin(unsigned long long tsLowBound) {
    minT = tsLowBound;
    maxT = tsLowBound + timeSliceLength;
  }
 
  struct PointHandler {
    virtual ~PointHandler() {}
    virtual void HandlePoint(const LxTbBinnedPoint& point) = 0;
  };
 
  void Search(scaltype x,
              scaltype xDiv0,
              scaltype y,
              scaltype yDiv0,
              timetype t,
              PointHandler* pointHandler) {
    scaltype wX = NOF_SIGMAS * std::sqrt(xDiv0 + maxDx * maxDx);
    scaltype wY = NOF_SIGMAS * std::sqrt(yDiv0 + maxDy * maxDy);
    timetype wT = NOF_SIGMAS * std::sqrt(2.0) * maxDt;
 
    if (x + wX < minX || x - wX > maxX || y + wY < minY || y - wY > maxY
        || t + wT < minT || t - wT > maxT)
      return;
 
    int tIndMin = (t - wT - minT) / binSizeT;
 
    if (tIndMin < 0)
      tIndMin = 0;
    else if (tIndMin > lastTBin)
      tIndMin = lastTBin;
 
    int tIndMax = (t + wT - minT) / binSizeT;
 
    if (tIndMax < 0)
      tIndMax = 0;
    else if (tIndMax > lastTBin)
      tIndMax = lastTBin;
 
    int yIndMin = (y - wY - minY) / binSizeY;
 
    if (yIndMin < 0)
      yIndMin = 0;
    else if (yIndMin > lastYBin)
      yIndMin = lastYBin;
 
    int yIndMax = (y + wY - minY) / binSizeY;
 
    if (yIndMax < 0)
      yIndMax = 0;
    else if (yIndMax > lastYBin)
      yIndMax = lastYBin;
 
    int xIndMin = (x - wX - minX) / binSizeX;
 
    if (xIndMin < 0)
      xIndMin = 0;
    else if (xIndMin > lastXBin)
      xIndMin = lastXBin;
 
    int xIndMax = (x + wX - minX) / binSizeX;
 
    if (xIndMax < 0)
      xIndMax = 0;
    else if (xIndMax > lastXBin)
      xIndMax = lastXBin;
 
    for (int tInd = tIndMin; tInd <= tIndMax; ++tInd) {
      LxTbTYXBin& tyxBin = tyxBins[tInd];
 
      for (int yInd = yIndMin; yInd <= yIndMax; ++yInd) {
        LxTbYXBin& yxBin = tyxBin.yxBins[yInd];
 
        for (int xInd = xIndMin; xInd <= xIndMax; ++xInd) {
          LxTbXBin& xBin = yxBin.xBins[xInd];
 
          for (std::list<LxTbBinnedPoint>::iterator i = xBin.points.begin();
               i != xBin.points.end();
               ++i) {
            LxTbBinnedPoint& point = *i;
            scaltype xDiv          = xDiv0 + point.dx * point.dx;
            scaltype wX_prec_sq    = NOF_SIGMAS_SQ * xDiv;
            scaltype yDiv          = yDiv0 + point.dy * point.dy;
            scaltype wY_prec_sq    = NOF_SIGMAS_SQ * yDiv;
            scaltype deltaX        = point.x - x;
            scaltype deltaXSq      = deltaX * deltaX;
            scaltype deltaY        = point.y - y;
            scaltype deltaYSq      = deltaY * deltaY;
            timetype deltaT        = point.t - t;
            timetype deltaTSq      = deltaT * deltaT;
 
            if (deltaXSq < wX_prec_sq && deltaYSq < wY_prec_sq
                && deltaTSq < wT * wT)
              //{
              //rPoint.neighbours.push_back(LxTbBinnedRay(deltaZ, rPoint, lPoint, deltaXSq / xDiv +
              //deltaYSq / yDiv + deltaTSq / (rPoint.dt * rPoint.dt + lPoint.dt * lPoint.dt)));
              pointHandler->HandlePoint(point);
            //}
          }
        }
      }
    }
  }
};
 
struct LxTBBinnedStsTrack {
  FairTrackParam fPar;
  Double_t fChiSq;
  Double_t fTime;
  Int_t fSelfId;
  //Int_t fEventId;
  //Int_t fFileId;
};
 
struct LxTBBinnedDetector {
  LxTBBinndedLayer* fLayers;
  int fNofLayers;
  std::list<LxTBBinnedStsTrack> fStsTracks;
  TClonesArray* fMuchTracks;
  TClonesArray* fGlobalTracks;
 
  LxTBBinnedDetector(int nofl, int nofxb, int nofyb, int noftb, int binSizeT);
  LxTBBinnedDetector(const LxTBBinnedDetector&) = delete;
  LxTBBinnedDetector& operator=(const LxTBBinnedDetector&) = delete;
 
  void Init();
  void Clear();
  void SetTSBegin(unsigned long long tsLowBound);
  void AddStsTrack(const FairTrackParam& par,
                   Double_t chiSq,
                   Double_t time,
                   Int_t selfId /*, Int_t eventId, Int_t fileId*/);
  void TieTracks(LxTbBinnedFinder& fFinder);
};
 
#endif /* LXTBTIETRACKS_H */