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;
  };

}