CbmL1RichENNRingFinderParallel.h

Go to the documentation of this file.

/* Copyright (C) 2010-2021 Frankfurt Institute for Advanced Studies, Goethe-Universitaet Frankfurt, Frankfurt
   SPDX-License-Identifier: GPL-3.0-only
   Authors: Ivan Kisel, Sergey Gorbunov, Igor Kulakov [committer] */
 
/*
 *====================================================================
 *
 *  CBM Level 1 Reconstruction 
 *  
 *  Authors: I.Kisel,  S.Gorbunov
 *
 *  e-mail : ikisel@kip.uni-heidelberg.de 
 *
 *====================================================================
 *
 *  Standalone RICH ring finder based on the Elastic Neural Net
 *
 *====================================================================
 */
 
#ifndef _CBM_L1_RICH_ENN_RING_FINDER2_H_
#define _CBM_L1_RICH_ENN_RING_FINDER2_H_
 
 
#include "CaSimd.h"
#include "CaVector.h"
#include "CbmRichRingFinder.h"
#include "TStopwatch.h"
#include "TString.h"
 
class ENNHit;
class ENNRing;
 
namespace
{
  using cbm::algo::ca::fmask;
  using cbm::algo::ca::fscal;
  using cbm::algo::ca::fvec;
}  // namespace
 
class CbmL1RichENNRingFinderParallel : public CbmRichRingFinder {
 
  typedef unsigned short THitIndex;
  struct ENNHit {
    ENNHit() : x(0), y(0), quality(0), localIndex(0){};
    virtual ~ENNHit(){};
 
    float x, y;            // coordinates
    int quality;           // quality of the best ring with this hit
    THitIndex localIndex;  // index in local copy of Clone array
 
    static bool Compare(const ENNHit& h1, const ENNHit& h2) { return (h1.x < h2.x); };
  };
 
 
  struct ENNRingHit : public ENNHit {  
    ENNRingHit() : outIndex(0){};
 
    THitIndex outIndex;  // index in Clone Array
  };
 
  struct ENNHitV {
    ENNHitV() : x(0), y(0), quality(0), localIndex(0){};
    virtual ~ENNHitV(){};
 
    fvec x, y;        // coordinates
    fvec quality;     // quality of the best ring with this hit
    fvec localIndex;  // index in local copy of Clone array
    void CopyHit(ENNHit& a, int i)
    {
      localIndex[i] = a.localIndex;
      x[i]          = a.x;
      y[i]          = a.y;
      quality[i]    = a.quality;
    }
    void CopyHit(ENNHitV& a, int j, int i)
    {
      localIndex[i] = a.localIndex[j];
      x[i]          = a.x[j];
      y[i]          = a.y[j];
      quality[i]    = a.quality[j];
    };
  };
 
  struct ENNRingHitV : public ENNHitV {
    ENNRingHitV() : outIndex(0){};
 
    fvec outIndex;  // index in local copy of Clone array
 
    void CopyHit(ENNRingHit& a, int i)
    {
      outIndex[i] = a.outIndex;
      ENNHitV::CopyHit(a, i);
    }
    void CopyHit(ENNRingHitV& a, int j, int i)
    {
      outIndex[i] = a.outIndex[j];
      ENNHitV::CopyHit(a, j, i);
    };
  };
 
  struct ENNSearchHitV : public ENNHitV {  
    ENNSearchHitV()
      : lx(0)
      , ly(0)
      , lr2(0)
      ,  // local coordinates
      S0(0)
      , S1(0)
      , S2(0)
      , S3(0)
      , S4(0)
      ,  // coefficients for calculation of E
      C(0)
      , Cx(0)
      , Cy(0)
      ,  // coefficients for the parameter space
      on_ring(fmask::One()){};
 
    // variables for local search:
    fvec lx, ly, lr2;         // local coordinates
    fvec S0, S1, S2, S3, S4;  // coefficients for calculation of E
    fvec C, Cx, Cy;           // coefficients for the parameter space
    fmask on_ring;            // is the hit close to the current ring
  };
 
 
  struct ENNRing {
    ENNRing()
      : on(0)
      ,  // is the ring selected?
      x(0)
      , y(0)
      , r(0)
      ,  // parameters
      chi2(0)
      ,  // chi^2
      NHits(0)
      ,  // number of ring hits
      NOwn(0)
      ,  // number of its own hits
      skip(0)
      ,  // skip the ring during selection
      localIHits(){};
 
    bool on;        // is the ring selected?
    float x, y, r;  // parameters
    float chi2;     // chi^2
    // variables for the selection procedure:
    THitIndex NHits;                    // number of ring hits
    THitIndex NOwn;                     // number of its own hits
    bool skip;                          // skip the ring during selection
    std::vector<THitIndex> localIHits;  // indexes of hits in local array
 
    static bool CompareENNHRings(const ENNRing& r1, const ENNRing& r2)
    {
      if (r1.NHits != r2.NHits)
        return (r1.NHits > r2.NHits);
      else
        return (r1.chi2 < r2.chi2);
    };
  };
 
  struct ENNRingV {
    ENNRingV()
      : x(0)
      , y(0)
      , r(0)
      ,  // parameters
      chi2(0)
      ,  // chi^2
      NHits(0)
      ,  // number of ring hits
      localIHits(){};
 
    fvec x, y, r;  // parameters
    fvec chi2;     // chi^2
 
    fvec NHits;                    // number of ring hits
    std::vector<fvec> localIHits;  // indexes of hits in local array
  };
 
 
  void ENNRingFinder(const int NHits, cbm::algo::ca::Vector<ENNHitV>& HitsV, std::vector<ENNRing>& Rings,
                     float HitSize = 1., THitIndex MinRingHits = 5, fvec RMin = 2., fvec RMax = 6.);
 
 public:
  CbmL1RichENNRingFinderParallel(Int_t verbose = 0);
 
  ~CbmL1RichENNRingFinderParallel();
 
  void Init();
 
  Int_t DoFind(CbmEvent* event, TClonesArray* hitArray, TClonesArray* projArray, TClonesArray* ringArray);
 
 private:
  Float_t fRecoTime;
  Int_t fNEvents;
 
  enum
  {
    NTimers = 11
  };
  TStopwatch fTimers[NTimers];    // timers for different parts of algorithm
  TString fTimersNames[NTimers];  // names which are correspond to the timers.
  TStopwatch& GetTimer(TString t);
};
 
#endif