TrackSegmentFinder.h

/**************************************************************************
 * basf2 (Belle II Analysis Software Framework)                           *
 * Author: The Belle II Collaboration                                     *
 *                                                                        *
 * See git log for contributors and copyright holders.                    *
 * This file is licensed under LGPL-3.0, see LICENSE.md.                  *
 **************************************************************************/
 
//-----------------------------------------------------------------------------
// Description : A class to find Track Segments
//-----------------------------------------------------------------------------
 
#ifndef TRGCDCTrackSegmentFinder_FLAG_
#define TRGCDCTrackSegmentFinder_FLAG_
 
#include <TFile.h>
#include <TTree.h>
#include <TClonesArray.h>
#include "trg/trg/Board.h"
#include "trg/trg/SignalVector.h"
#include "trg/trg/SignalBundle.h"
 
#ifdef TRGCDC_SHORT_NAMES
#define TCTSFinder TRGCDCTrackSegmentFinder
#define TSFinder TRGCDCTrackSegmentFinder
#endif
 
namespace Belle2 {
  class TRGCDC;
  class TRGCDCSegment;
  class TRGCDCSegmentHit;
  class TRGCDCMerger;
 
  class TRGCDCTrackSegmentFinder
    : public TRGBoard,
      public std::vector <const TRGCDCMerger*> {
 
  public:
    enum boardType {
      innerType = 0,
      outerType = 1,
      unknown   = 999
    };
 
    TRGCDCTrackSegmentFinder(const TRGCDC&,
                             bool makeRootFile,
                             bool logicLUTFlag);
 
    TRGCDCTrackSegmentFinder(const  TRGCDC&,
                             const std::string& name,
                             boardType type,
                             const TRGClock& systemClock,
                             const TRGClock& dataClock,
                             const TRGClock& userClockInput,
                             const TRGClock& userClockOutput,
                             const std::vector<TRGCDCSegment*>& tsSL);
 
    ~TRGCDCTrackSegmentFinder();
 
 
    void doit(std::vector<TRGCDCSegment* >& tss, const bool trackSegmentClockSimulation,
              std::vector<TRGCDCSegmentHit* >& segmentHits, std::vector<TRGCDCSegmentHit* >* segmentHitsSL);
    void terminate(void);
    void saveTSInformation(std::vector<TRGCDCSegment* >& tss);
    void saveTSFResults(std::vector<TRGCDCSegmentHit* >* segmentHitsSL);
    void saveNNTSInformation(std::vector<TRGCDCSegment* >& tss);
 
 
    const TRGCDC& _cdc;
    bool m_logicLUTFlag;
 
    std::string m_rootTSFFilename;
    TFile* m_fileTSF;
 
    TTree* m_treeInputTSF = nullptr;
    // Stores hitpattern information. 9 components
    // [mc particle id, superlayer id, hitpattern, priorityLR, priorityPhi, secondPriorityRLR, secondPriorityRPhi, secondPriorityLLR, secondPriorityLPhi]
    TClonesArray* m_hitPatternInformation = nullptr;
 
    TTree* m_treeOutputTSF = nullptr;
    TClonesArray* m_particleEfficiency = nullptr;
    TClonesArray* m_tsInformation = nullptr;
 
    TTree* m_treeNNTSF = nullptr;
    TClonesArray* m_nnPatternInformation = nullptr;
 
    bool m_makeRootFile = false;
 
  public:
 
    static std::string version(void);
 
//    /// Make bit pattern for Inner-most Tracker
//    static TRGState packerInnerTracker(const TRGState & input);
//
//    /// Make bit pattern for Outer Tracker
//    static TRGState packerOuterTracker(const TRGState & input);
//
//    /// Make bit pattern for Inner-most EvtTime & Low Pt Tracker
//    static TRGState packerInnerEvt(const TRGState & input);
//
//    /// Make bit pattern for Outer EvtTime & Low Pt Tracker
//    static TRGState packerOuterEvt(const TRGState & input);
 
    vector<TRGSignalVector*> findTSHit(TRGSignalVector* eachInput, int);
 
    TRGSignalVector* packerOuterTracker(vector<TRGSignalVector*>&,
                                        vector<int>&,
                                        const unsigned);
 
    TRGSignalVector* packerOuterEvt(vector<TRGSignalVector*>, vector<int>, int);
    boardType type(void) const;
 
    TRGSignalBundle* outputE(void) {return _tosbE;};
    TRGSignalBundle* outputT(void) {return _tosbT;};
 
    void push_back(const TRGCDCMerger*);
 
    void simulateBoard(void);
 
    void simulate(void);
 
    void simulate2(void);
 
    void hitMapInner(void);
 
    void hitMapOuter(void);
 
    void inputInner(const unsigned id,
                    const unsigned nTSF,
                    TRGSignalVector* s);
 
    void inputOuter(const unsigned id,
                    const unsigned nTSF,
                    TRGSignalVector* s);
 
    vector<TRGSignalVector*> simulateInner(const TRGSignalVector& in,
                                           unsigned id);
 
    vector<TRGSignalVector*> simulateOuter(TRGSignalVector* in,
                                           unsigned id);
 
    vector<TRGSignalVector*> simulateTSFOld(TRGSignalVector* in,
                                            unsigned id);
 
    vector<TRGSignalVector*> simulateTSF(TRGSignalVector* in,
                                         unsigned id);
 
    vector<TRGSignalVector*> simulateTSF2(TRGSignalVector* in,
                                          unsigned id);
 
    TRGSignalVector* packerForTracker(vector<TRGSignalVector*>&,
                                      vector<int>&,
                                      const unsigned);
 
    TRGSignalVector* packerForETF(vector<TRGSignalVector*>&,
                                  vector<int>&,
                                  const unsigned);
    double mkint(TRGState);
 
    vector<bool> mkbool(int, int);
 
  private:
 
    void simulateInner(void);
 
    void simulateOuter(void);
 
    void priorityTiming(unsigned tsfID,
                        const unsigned nTSF,
                        TRGSignalVector& s,
                        const TRGSignal& center,
                        const TRGSignal& right,
                        const TRGSignal& left) const;
 
    void fastestTimingInner(unsigned tsfID,
                            const unsigned nTSF,
                            TRGSignalVector& s) const;
 
    void fastestTimingOuter(unsigned tsfID,
                            const unsigned nTSF,
                            TRGSignalVector& s) const;
 
    static void addID(TRGSignalVector& s, unsigned id);
 
  private:
 
    boardType _type;
 
    //TRGSignalBundle * _tisb;
 
    TRGSignalBundle* _tosbE;
    TRGSignalBundle* _tosbT;
    std::vector<TCSegment*> _tsSL;
 
    std::vector<TRGSignalVector*> _tsfIn;
 
    std::vector<TRGSignalVector*> _tsfOut;
 
    std::vector<TRGSignalVector*> _toBeDeleted;
 
    std::vector<TRGSignal* > _hitMap[5];
 
    std::vector<TRGSignal* > _priMap;
 
    std::vector<TRGSignal* > _fasMap;
 
    std::vector<TRGSignal* > _secMap;
 
    std::vector<TRGSignal* > _edg0Map;
 
    std::vector<TRGSignal* > _edg1Map;
 
    std::vector<TRGSignal* > _edg2Map;
 
    std::vector<TRGSignal* > _edg3Map;
 
    std::vector<TRGSignal* > _edg4Map;
  };
 
} // namespace Belle2
 
#endif