DirectedNodeNetworkContainer.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 <deque>
 
#include <framework/datastore/RelationsObject.h>
 
#include <tracking/spacePointCreation/SpacePoint.h>
#include <tracking/trackFindingVXD/segmentNetwork/DirectedNodeNetwork.h>
#include <tracking/trackFindingVXD/environment/VXDTFFilters.h>
#include <tracking/trackFindingVXD/segmentNetwork/TrackNode.h>
#include <tracking/trackFindingVXD/segmentNetwork/Segment.h>
#include <tracking/trackFindingVXD/segmentNetwork/ActiveSector.h>
#include <tracking/trackFindingVXD/segmentNetwork/VoidMetaInfo.h>
#include <tracking/trackFindingVXD/segmentNetwork/CACell.h>
 
 
namespace Belle2 {
  class DirectedNodeNetworkContainer : public RelationsObject {
  public:
    using StaticSectorType = VXDTFFilters<SpacePoint>::staticSector_t;
 
 
    DirectedNodeNetworkContainer() :
      m_ActiveSectorNetwork(DirectedNodeNetwork<ActiveSector<StaticSectorType, Belle2::TrackNode>, Belle2::VoidMetaInfo>()),
      m_HitNetwork(DirectedNodeNetwork<Belle2::TrackNode, Belle2::VoidMetaInfo>()),
      m_SegmentNetwork(DirectedNodeNetwork<Belle2::Segment<Belle2::TrackNode>, Belle2::CACell>()),
      m_VirtualInteractionPoint(nullptr),
      m_VIPSpacePoint(nullptr) {}
 
 
    ~DirectedNodeNetworkContainer()
    {
      if (m_VirtualInteractionPoint != nullptr) { delete m_VirtualInteractionPoint; }
      if (m_VIPSpacePoint != nullptr) { delete m_VIPSpacePoint; }
    }
 
 
 
    DirectedNodeNetwork<Belle2::ActiveSector<StaticSectorType, Belle2::TrackNode>, Belle2::VoidMetaInfo>&
    accessActiveSectorNetwork() { return m_ActiveSectorNetwork; }
 
    std::deque<Belle2::ActiveSector<StaticSectorType, Belle2::TrackNode>>& accessActiveSectors() { return m_activeSectors; }
 
    std::deque<Belle2::TrackNode>& accessTrackNodes() { return m_trackNodes; }
 
    DirectedNodeNetwork<Belle2::TrackNode, Belle2::VoidMetaInfo>& accessHitNetwork() { return m_HitNetwork; }
 
    DirectedNodeNetwork<Belle2::Segment<Belle2::TrackNode>, Belle2::CACell >& accessSegmentNetwork() { return m_SegmentNetwork; }
 
    std::deque<Belle2::Segment<Belle2::TrackNode>>& accessSegments() { return m_segments; }
 
 
    int sizeActiveSectors() { return m_activeSectors.size(); }
    int sizeTrackNodes() { return m_trackNodes.size(); }
    int sizeSegments() { return m_segments.size(); }
 
    int get_trackNodesCollected() { return m_trackNodesCollected; }
    int get_activeSectorConnections() { return m_activeSectorConnections; }
    int get_trackNodeConnections() { return m_trackNodeConnections; }
    int get_segmentConnections() { return m_segmentConnections; }
    int get_activeSectorAddedConnections() { return m_activeSectorAddedConnections; }
    int get_trackNodeAddedConnections() { return m_trackNodeAddedConnections; }
    int get_segmentAddedConnections() { return m_segmentAddedConnections; }
    int get_collectedPaths() { return m_collectedPaths; }
 
    void set_trackNodesCollected(int in) { m_trackNodesCollected = in; }
    void set_activeSectorConnections(int in) { m_activeSectorConnections = in; }
    void set_trackNodeConnections(int in) { m_trackNodeConnections = in; }
    void set_segmentConnections(int in) { m_segmentConnections = in; }
    void set_activeSectorAddedConnections(int in) { m_activeSectorAddedConnections = in; }
    void set_trackNodeAddedConnections(int in) { m_trackNodeAddedConnections = in; }
    void set_segmentAddedConnections(int in) { m_segmentAddedConnections = in; }
    void set_collectedPaths(int in) { m_collectedPaths = in; }
 
    void clear()
    {
      m_SegmentNetwork.clear();
    }
 
    void setVirtualInteractionPoint(B2Vector3D& pos, B2Vector3D& posError)
    {
      m_VIPSpacePoint = new SpacePoint(pos, posError, {0.5, 0.5}, {false, false}, VxdID(0), Belle2::VXD::SensorInfoBase::VXD);
      m_VirtualInteractionPoint = new Belle2::TrackNode(m_VIPSpacePoint);
    }
 
    Belle2::TrackNode* getVirtualInteractionPoint() { return m_VirtualInteractionPoint; }
 
 
  private:
    ClassDef(DirectedNodeNetworkContainer, 0);
 
  protected:
 
    int m_trackNodesCollected = 0;
    int m_activeSectorConnections = 0;
    int m_trackNodeConnections = 0;
    int m_segmentConnections = 0;
    int m_activeSectorAddedConnections = 0;
    int m_trackNodeAddedConnections = 0;
    int m_segmentAddedConnections = 0;
    int m_collectedPaths = 0;
 
    DirectedNodeNetwork<ActiveSector<StaticSectorType, TrackNode>, Belle2::VoidMetaInfo> m_ActiveSectorNetwork;
 
    std::deque<ActiveSector<StaticSectorType, TrackNode>> m_activeSectors;
 
    DirectedNodeNetwork<TrackNode, Belle2::VoidMetaInfo> m_HitNetwork;
 
    std::deque<TrackNode> m_trackNodes;
 
    DirectedNodeNetwork<Segment<TrackNode>, Belle2::CACell> m_SegmentNetwork;
 
    std::deque<Segment<TrackNode>> m_segments;
 
    Belle2::TrackNode* m_VirtualInteractionPoint;
 
    SpacePoint* m_VIPSpacePoint;
  };
}