SegmentNetworkProducerModule.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 <string>
#include <vector>
 
#include <framework/datastore/StoreArray.h>
#include <framework/datastore/StoreObjPtr.h>
#include <framework/core/Module.h>
#include <framework/logging/Logger.h>
#include <framework/geometry/B2Vector3.h>
 
#include <mdst/dataobjects/EventLevelTrackingInfo.h>
 
#include <tracking/trackFindingVXD/segmentNetwork/DirectedNodeNetworkContainer.h>
#include <tracking/trackFindingVXD/segmentNetwork/TrackNode.h>
#include <tracking/spacePointCreation/SpacePoint.h>
#include <tracking/dataobjects/FullSecID.h>
#include <tracking/trackFindingVXD/filterMap/map/FiltersContainer.h>
 
namespace Belle2 {
  class SegmentNetworkProducerModule : public Module {
 
  public:
    using StaticSectorType = VXDTFFilters<SpacePoint>::staticSector_t;
 
    struct RawSectorData {
      FullSecID secID;
 
      bool wasCreated;
 
      ActiveSector<StaticSectorType, TrackNode>* sector;
 
      const StaticSectorType* staticSector;
 
      std::vector<Belle2::TrackNode*> hits;
    };
 
    SegmentNetworkProducerModule();
 
    void initialize() override;
 
    void beginRun() override
    {
      m_vxdtfFilters = m_filtersContainer.getFilters(m_PARAMsecMapName);
      if (m_vxdtfFilters == nullptr) {
        B2FATAL("Requested secMapName '" << m_PARAMsecMapName << "' does not exist! Can not continue...");
      }
    }
 
    void event() override;
 
 
    std::vector<RawSectorData> matchSpacePointToSectors();
 
 
    const StaticSectorType* findSectorForSpacePoint(const SpacePoint& aSP)
    {
      if (not m_vxdtfFilters->areCoordinatesValid(aSP.getVxdID(), aSP.getNormalizedLocalU(), aSP.getNormalizedLocalV())) {
        return nullptr;
      }
 
      FullSecID spSecID = m_vxdtfFilters->getFullID(aSP.getVxdID(), aSP.getNormalizedLocalU(), aSP.getNormalizedLocalV());
      return m_vxdtfFilters->getStaticSector(spSecID);
    }
 
 
    void buildActiveSectorNetwork(std::vector<RawSectorData>& collectedData);
 
 
    template <class ObserverType>
    bool buildTrackNodeNetwork();
 
 
    template <class ObserverType>
    void buildSegmentNetwork();
 
 
  protected:
    std::vector<std::string> m_PARAMSpacePointsArrayNames = {"SVDSpacePoints", "PXDSpacePoints"};
 
    std::string m_PARAMNetworkOutputName;
 
    std::string m_PARAMEventLevelTrackingInfoName;
 
    bool m_PARAMAddVirtualIP = false;
 
    std::vector<double> m_PARAMVirtualIPCoordinates = {0, 0, 0};
 
    std::vector<double> m_PARAMVirtualIPErrors = {0.2, 0.2, 1.};
 
    std::string m_PARAMsecMapName = "testMap";
 
    bool m_PARAMprintNetworks = false;
 
    bool m_PARAMprintToMathematica = false;
 
    bool m_PARAMallFiltersOff = false;
 
    unsigned short m_PARAMmaxNetworkSize = 40000;
 
    unsigned int m_PARAMmaxSegmentConnections = 30000;
 
    unsigned int m_PARAMmaxSegmentAddedConnections = 300000;
 
    unsigned short m_PARAMmaxTrackNodeConnections = 8000;
 
    unsigned int m_PARAMmaxTrackNodeAddedConnections = 200000;
 
 
    B2Vector3D m_virtualIPCoordinates;
 
    B2Vector3D m_virtualIPErrors;
 
    FiltersContainer<SpacePoint>& m_filtersContainer = FiltersContainer<SpacePoint>::getInstance();
 
    VXDTFFilters<SpacePoint>* m_vxdtfFilters = nullptr;
 
    std::vector<StoreArray<Belle2::SpacePoint>> m_spacePoints;
 
    StoreObjPtr<DirectedNodeNetworkContainer> m_network;
 
    StoreObjPtr<EventLevelTrackingInfo> m_eventLevelTrackingInfo;
 
 
    unsigned int m_eventCounter = 0;
  };
}