CDCTriggerHoughETFModule.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.                  *
 **************************************************************************/
 
#ifndef CDCTriggerHoughETFModule_H
#define CDCTriggerHoughETFModule_H
 
#include <framework/core/Module.h>
 
#include <utility>
#include <map>
#include <vector>
#include <fstream>
 
#include <framework/datastore/StoreArray.h>
#include <framework/datastore/StoreObjPtr.h>
#include <trg/cdc/dataobjects/CDCTriggerSegmentHit.h>
#include <trg/cdc/dataobjects/CDCTriggerTrack.h>
#include <trg/cdc/dataobjects/CDCTriggerHoughCluster.h>
#include <framework/dataobjects/BinnedEventT0.h>
 
#include <TMatrix.h>
#include <Math/Vector2D.h>
 
namespace Belle2 {
  typedef std::pair<unsigned short, ROOT::Math::XYVector> cdcPair;
  typedef std::map<int, cdcPair> cdcMap;
  typedef std::pair<ROOT::Math::XYVector, ROOT::Math::XYVector> coord2dPair;
 
  class CDCTriggerHoughCand {
  public:
    CDCTriggerHoughCand(std::vector<unsigned>& _list, coord2dPair _coord,
                        unsigned short _slcount, unsigned _id):
      hitList(_list), coord(_coord), SLcount(_slcount), id(_id) {}
 
    ~CDCTriggerHoughCand() {}
 
    std::vector<unsigned> getIdList() const { return hitList; }
    coord2dPair getCoord() const { return coord; }
    unsigned short getSLcount() const { return SLcount; }
    unsigned getID() const { return id; }
 
  private:
    std::vector<unsigned> hitList;
    coord2dPair coord;
    unsigned short SLcount = 0;
    unsigned id = 0;
  };
 
  inline bool operator==(const CDCTriggerHoughCand& a, const CDCTriggerHoughCand& b)
  {
    return (a.getCoord().first.X() == b.getCoord().first.X() &&
            a.getCoord().first.Y() == b.getCoord().first.Y());
  }
 
 
  class CDCTriggerHoughETFModule : public Module {
  public:
    CDCTriggerHoughETFModule();
 
    virtual void initialize() override;
    virtual void event() override;
    virtual void terminate() override;
 
    int fastInterceptFinder(cdcMap& hits,
                            double x1_s, double x2_s, double y1_s, double y2_s,
                            unsigned iterations,
                            unsigned ix_s, unsigned iy_s);
 
    unsigned short countSL(bool* superLayers);
    bool shortTrack(bool* superLayers);
 
    void connectedRegions();
    void addNeighbors(const CDCTriggerHoughCand& center,
                      const std::vector<CDCTriggerHoughCand>& candidates,
                      std::vector<CDCTriggerHoughCand>& merged,
                      std::vector<CDCTriggerHoughCand>& rejected,
                      unsigned short nSLmax) const;
    bool inList(const CDCTriggerHoughCand& a, const std::vector<CDCTriggerHoughCand>& list) const;
    bool connected(const CDCTriggerHoughCand& a, const CDCTriggerHoughCand& b) const;
    void mergeIdList(std::vector<unsigned>& merged, std::vector<unsigned>& a, std::vector<unsigned>& b);
 
    bool patternClustering(const cdcMap& inputMap);
    bool connectedLR(unsigned patternL, unsigned patternR);
    bool connectedUD(unsigned patternD, unsigned patternU);
    bool connectedDiag(unsigned patternLD, unsigned patternRU);
    unsigned topRightSquare(std::vector<unsigned>& pattern);
    unsigned topRightCorner(unsigned pattern);
    unsigned bottomLeftCorner(unsigned pattern);
 
    void findAllCrossingHits(std::vector<unsigned>& list,
                             double x1, double x2, double y1, double y2,
                             const cdcMap& inputMap);
    void selectHits(std::vector<unsigned>& list, std::vector<unsigned>& selected,
                    std::vector<unsigned>& unselected);
 
    int getSector(int id, int sl);
    std::vector<int> sectorTimingList();
    std::vector<int> highPassTimingList();
    int calcEventTiming();
    int median(std::vector<int> v);
    int medianInTimeWindow(std::vector<int> v);
 
 
 
  protected:
 
    StoreObjPtr<BinnedEventT0> m_eventTime;
    std::string m_EventTimeName;
    bool m_storeTracks;
    StoreArray<CDCTriggerSegmentHit> m_hits;
    std::vector<std::vector<CDCTriggerSegmentHit*>> associatedTSHitsList;
    bool m_usePriorityTiming;
    bool m_useHighPassTimingList;
    unsigned m_t0CalcMethod;
    unsigned m_arrivalOrder;
    short m_timeWindowBegin;
    short m_timeWindowEnd;
 
 
    std::string m_hitCollectionName;
    std::string m_outputCollectionName;
    std::string m_clusterCollectionName;
    unsigned m_nCellsPhi;
    unsigned m_nCellsR;
    double m_minPt;
    int m_shiftPt;
    double maxR = 0.;
    double shiftR = 0.;
    unsigned maxIterations = 0;
    unsigned nCells = 0;
 
    unsigned m_minHits;
    unsigned m_minHitsShort;
    unsigned m_minCells;
    bool m_onlyLocalMax;
    unsigned m_connect;
    bool m_ignore2nd;
    bool m_usePriority;
    bool m_requireSL0;
 
    bool m_suppressClone;
 
    unsigned m_storePlane;
    bool m_clusterPattern;
    unsigned m_clusterSizeX;
    unsigned m_clusterSizeY;
    bool m_hitRelationsFromCorners;
 
    int m_offset = 0;
 
    std::string m_testFilename;
    std::ofstream testFile;
 
    cdcMap hitMap;
    std::vector<CDCTriggerHoughCand> houghCand;
 
    double radius[9][2] = {{0.}};
    unsigned TSoffset[10] = {0};
    const int NTS  [9] = {160, 160, 192, 224, 256, 288, 320, 352, 384};
    const int NSEC [9] = {16, 0, 16, 0, 16, 0, 8, 0, 8};
    int NSecOffset [9] = {0};
 
    StoreArray<CDCTriggerSegmentHit> m_segmentHits;
    StoreArray<CDCTriggerTrack> m_tracks;
    StoreArray<CDCTriggerHoughCluster> m_clusters;
    StoreObjPtr<TMatrix> m_houghPlane;
  };//end class declaration
} // end namespace Belle2
 
#endif // CDCTrigger2DFinderModule_H