FastInterceptFinder2DFPGA.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.                  *
 **************************************************************************/
#pragma once
 
#include <tracking/trackFindingCDC/findlets/base/Findlet.h>
#include <tracking/datcon/utilities/DATCONHelpers.h>
 
#include <string>
#include <vector>
#include <iostream>
#include <fstream>
#include <algorithm>
#include <cmath>
 
namespace Belle2 {
  class ModuleParamList;
  class VxdID;
 
  class FastInterceptFinder2DFPGA : public
    TrackFindingCDC::Findlet<const std::pair<VxdID, std::pair<long, long>>, std::pair<double, double>> {
    using Super = TrackFindingCDC::Findlet<const std::pair<VxdID, std::pair<long, long>>, std::pair<double, double>>;
 
  public:
    FastInterceptFinder2DFPGA();
 
    void exposeParameters(ModuleParamList* moduleParamList, const std::string& prefix) override;
 
    void initialize() override;
 
    void apply(const std::vector<std::pair<VxdID, std::pair<long, long>>>& hits,
               std::vector<std::pair<double, double>>& tracks) override;
 
  private:
 
    inline unsigned short layerFilter(std::vector<bool> layer)
    {
      uint layercount = std::count(layer.begin(), layer.end(), true);
      return (layercount >= 3 ? layercount : 0);
    }
 
    void fastInterceptFinder2d(const std::vector<std::pair<VxdID, std::pair<long, long>>>& hits,
                               uint xmin, uint xmax, uint ymin, uint ymax, uint currentRecursion);
 
    void FindHoughSpaceCluster();
 
    void DepthFirstSearch(uint lastIndexX, uint lastIndexY);
 
    void gnuplotoutput(const std::vector<std::pair<VxdID, std::pair<long, long>>>& hits);
 
    // Parameters
    bool m_param_isUFinder = true;
 
    uint m_param_maxRecursionLevel = 6;
 
    uint m_param_nAngleSectors = 256;
 
    uint m_param_nVerticalSectors = 256;
 
    long m_param_verticalHoughSpaceSize = convertFloatToInt(64, 6);
 
    double m_param_minimumX = -3.168;
    double m_param_maximumX = 3.168;
 
    double m_unitX = 0;
    double m_unitY = 0;
 
    uint m_param_MinimumHSClusterSize = 3;
    uint m_param_MaximumHSClusterSize = 1000;
    uint m_param_MaximumHSClusterSizeX = 1000;
    uint m_param_MaximumHSClusterSizeY = 1000;
 
    std::array<long, 16385> m_HSSinValuesLUT = {0};
    std::array<long, 16385> m_HSCosValuesLUT = {0};
    std::array<long, 16384> m_HSCenterSinValuesLUT = {0};
    std::array<long, 16384> m_HSCenterCosValuesLUT = {0};
    std::array<long, 16385> m_HSYLUT = {0};
    std::array<long, 16384> m_HSYCenterLUT = {0};
    std::array<double, 16385> m_HSXLUT = {0};
    std::array<double, 16384> m_HSXCenterLUT = {0};
 
    std::vector<int> m_SectorArray;
    std::vector<std::pair<uint, uint>> m_activeSectorArray;
 
    uint m_clusterCount = 0;
    uint m_clusterSize = 0;
 
    bool m_param_writeGnuplotOutput = false;
    std::string m_param_gnuplotHSOutputFileName = "HSFPGA.plt";
    std::string m_param_gnuplotHSRectOutputFileName = "HSFPGARect.plt";
    std::string m_param_gnuplotHSCoGOutputFileName = "HSFPGACoG.plt";
    std::ofstream m_rectoutstream;
    std::ofstream m_cogoutstream;
    const std::string m_const_rectColor[8] = {"blue", "cyan", "green", "yellow", "orange", "violet", "skyblue", "pink"};
    uint m_rectcounter = 1;
 
    std::pair<int, int> m_clusterInitialPosition = std::make_pair(0, 0);
    std::pair<int, int> m_clusterCoG = std::make_pair(0, 0);
 
    std::vector<std::pair<double, double>> m_trackCandidates;
 
  };
}