DATCONTrackingModule.h

/**************************************************************************
 * BASF2 (Belle Analysis Framework 2)                                     *
 * Copyright(C) 2013 - Belle II Collaboration                             *
 *                                                                        *
 * Author: The Belle II Collaboration                                     *
 * Contributors: Michael Schnell, Christian Wessel                        *
 *                                                                        *
 * This software is provided "as is" without any warranty.                *
 **************************************************************************/
 
#pragma once
 
#include <tracking/modules/DATCON/DATCONTrackCand.h>
#include <tracking/modules/DATCON/DATCONHoughCand.h>
#include <tracking/modules/DATCON/DATCONHoughSpaceClusterCand.h>
#include <tracking/dataobjects/DATCONSVDSpacePoint.h>
#include <tracking/dataobjects/DATCONTrack.h>
#include <tracking/dataobjects/DATCONSVDDigit.h>
 
#include <tracking/spacePointCreation/SpacePoint.h>
#include <tracking/dataobjects/RecoTrack.h>
 
#include <framework/core/Module.h>
#include <framework/datastore/StoreArray.h>
 
#include <mdst/dataobjects/MCParticle.h>
 
#include <root/TVector2.h>
#include <root/TVector3.h>
 
#include <svd/dataobjects/SVDCluster.h>
 
#include <vxd/dataobjects/VxdID.h>
 
 
namespace Belle2 {
  typedef std::pair<VxdID, TVector3> svdHitPair;
  typedef std::map<int, svdHitPair> svdHitMap;
  typedef std::pair<VxdID, TVector2> houghPair;
  typedef std::map<int, houghPair> houghMap;
 
  class DATCONTrackingModule : public Module {
  public:
    DATCONTrackingModule();
 
    virtual ~DATCONTrackingModule() = default;
 
    virtual void initialize() override;
    virtual void event() override;
    virtual void terminate() override;
 
    void addParameter();
 
    void prepareDATCONSVDSpacePoints();
 
    void prepareSVDSpacePoints();
 
    void houghTrafo2d(svdHitMap& mapClusters, bool u_side);
 
    int fastInterceptFinder2d(houghMap& hits, bool u_side, TVector2 v1_s,
                              TVector2 v2_s, TVector2 v4_s,
                              unsigned int iterations, unsigned int maxIterations);
    int slowInterceptFinder2d(houghMap& hits, bool u_side);
 
    void FindHoughSpaceCluster(bool u_side);
 
    void DepthFirstSearch(bool u_side, int** ArrayOfActiveHoughSpaceSectors, int angleSectors, int vertSectors,
                          int actualPositionX, int actualPositionY,
                          std::vector<unsigned int>& mergedList);
 
    bool layerFilter(bool* layer);
 
    /* Functions to purify track candidates */
    void purifyTrackCandsList();
 
    bool compareList(std::vector<unsigned int>& aList, std::vector<unsigned int>& bList);
 
    void mergeIdList(std::vector<unsigned int>& mergedList, std::vector<unsigned int>& mergeme);
 
    void trackCandMerger();
 
    void trackMerger();
 
    void findandcombine3d();
 
    void saveHitsToRecoTrack(std::vector<unsigned int>& idList, TVector3 momentum);
 
 
  protected:
 
    std::string m_storeMCParticlesName;
    std::string m_storeSVDSpacePointsName;
    std::string m_storeDATCONSVDDigitsName;
    std::string m_storeDATCONSVDClusterName;
    std::string m_storeDATCONSVDSpacePointsName;
    std::string m_storeDATCONTracksName;
    std::string m_storeDATCONRecoTracksName;
    std::string m_storeRecoHitInformationName;
 
    StoreArray<MCParticle> storeMCParticles;
    StoreArray<SpacePoint> storeSVDSpacePoints;
 
    StoreArray<DATCONSVDDigit> storeDATCONSVDDigits;
    StoreArray<SVDCluster> storeDATCONSVDCluster;
    StoreArray<DATCONSVDSpacePoint> storeDATCONSVDSpacePoints;
 
    StoreArray<RecoHitInformation> storeRecoHitInformation;
    StoreArray<RecoTrack> storeDATCONRecoTracks;
    StoreArray<DATCONTrack> storeDATCONTracks;
 
    // 2. Use DATCONSpacePoints or SVDSpacePoints?
    bool m_useDATCONSVDSpacePoints;
    bool m_useSVDSpacePoints;
 
    // 3. Hough Trafo Parameter
    double m_trackCenterX;
    double m_trackCenterY;
    unsigned short m_minimumLines;
    int m_maxIterationsU;
    int m_maxIterationsV;
 
    bool m_independentSectors;
    int m_nAngleSectorsU;
    int m_nAngleSectorsV;
    int m_nVertSectorsU;
    int m_nVertSectorsV;
    double m_rectSizeV;
    double m_rectSizeU;
 
    // 3.1 What to do in Simulations for Phase 2:
    bool m_usePhase2Simulation;
 
    // 4. Extracting Information from the Hough Space
    // 4.1 Use Purifier
    bool m_usePurifier;
 
    // 4.2 Use Hough Space Clustering
    bool m_useHoughSpaceClustering;
    int m_MinimumPhiHSClusterSize;
    int m_MaximumPhiHSClusterSize;
    int m_MaximumPhiHSClusterSizeX;
    int m_MaximumPhiHSClusterSizeY;
    int m_MinimumThetaHSClusterSize;
    int m_MaximumThetaHSClusterSize;
    int m_MaximumThetaHSClusterSizeX;
    int m_MaximumThetaHSClusterSizeY;
    int m_clusterSize;
    int m_clusterCount;
    TVector2 m_clusterInitialPosition;
    TVector2 m_clusterCenterOfGravity;
 
    // 5. Merge TrackCandidates or Tracks?
    bool m_useTrackCandMerger;
    bool m_useTrackCandMergerU;
    bool m_useTrackCandMergerV;
    double m_mergeThreshold;
    double m_mergeThresholdU;
    double m_mergeThresholdV;
    bool m_useTrackMerger;
    double m_mergeThresholdPhi;
    double m_mergeThresholdTheta;
 
    svdHitMap uClusters;
    svdHitMap vClusters;
 
    houghMap uHough;
    houghMap vHough;
 
    std::vector<DATCONHoughCand> uHoughCand;
    std::vector<DATCONHoughCand> vHoughCand;
 
    std::vector<DATCONHoughSpaceClusterCand> uHoughSpaceClusterCand;
    std::vector<DATCONHoughSpaceClusterCand> vHoughSpaceClusterCand;
 
    std::vector<DATCONTrackCand> uTrackCand;
    std::vector<DATCONTrackCand> vTrackCand;
 
    std::vector<DATCONTrack> DATCONTracks;
 
    std::vector<bool> activeSectorVectorPhi;
    std::vector<bool> activeSectorVectorTheta;
 
    int** ArrayOfActiveSectorsPhiHS;
    int** ArrayOfActiveSectorsThetaHS;
 
  };//end class declaration
} // end namespace Belle2