TrackNode.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/spacePointCreation/SpacePoint.h>
#include <tracking/trackFindingVXD/environment/VXDTFFilters.h>
#include <tracking/trackFindingVXD/segmentNetwork/ActiveSector.h>
 
#include <string>
 
namespace Belle2 {
  struct TrackNode {
    using StaticSectorType = VXDTFFilters<SpacePoint>::staticSector_t;

    TrackNode() {}

    explicit TrackNode(SpacePoint* spacePoint) :
      m_sector(nullptr), m_spacePoint(spacePoint), m_identifier(spacePoint->getArrayIndex())
    {}

    ~TrackNode() {}
 

    ActiveSector<StaticSectorType, TrackNode>* m_sector = nullptr;

    SpacePoint* m_spacePoint = nullptr;

    const std::int32_t m_identifier = -1;
 

    bool operator==(const TrackNode& b) const
    {
      // simple case: no null-ptrs interfering:
      if (m_spacePoint != nullptr and b.m_spacePoint != nullptr and m_sector != nullptr and b.m_sector != nullptr) {
        // compares objects:
        return (*m_spacePoint == *(b.m_spacePoint)) and (*m_sector == *(b.m_sector));
      }
 
      // case: at least one of the 2 nodes has no null-ptrs:
      if (m_spacePoint != nullptr and m_sector != nullptr) return false; // means: this Node has no null-Ptrs -> the other one has
      if (b.m_spacePoint != nullptr and b.m_sector != nullptr) return false; // means: the other Node has no null-Ptrs -> this one has
 
      // case: both nodes have got at least one null-ptr:
      bool spacePointsAreEqual = false;
      if (m_spacePoint != nullptr and b.m_spacePoint != nullptr) {
        spacePointsAreEqual = (*m_spacePoint == *(b.m_spacePoint));
      } else {
        spacePointsAreEqual = (m_spacePoint == b.m_spacePoint);
      }
      bool sectorsAreEqual = false;
      if (m_sector != nullptr and b.m_sector != nullptr) {
        sectorsAreEqual = (*m_sector == *(b.m_sector));
      } else {
        sectorsAreEqual = (m_sector == b.m_sector);
      }
      return (spacePointsAreEqual == true and sectorsAreEqual == true);
    }
 

    bool operator!=(const TrackNode& b) const
    {
      if (m_spacePoint == nullptr) {
        B2FATAL("TrackNode::operator !=: m_spacePoint for Tracknode not set - aborting run.");
      }
      return !(*this == b);
    }
 

    const SpacePoint& getHit() const
    {
      if (m_spacePoint == nullptr) {
        B2FATAL("TrackNode::getHit: m_spacePoint for Tracknode not set - aborting run.");
      }
      return *m_spacePoint;
    }
 

    ActiveSector<StaticSectorType, TrackNode>& getActiveSector()
    {
      if (m_sector == nullptr) {
        B2FATAL("TrackNode::getActiveSector: ActiveSector for Tracknode not set - aborting run.");
      }
      return *m_sector;
    }
 

    std::int32_t getID() const { return m_identifier; }
 

    std::string getName() const
    {
      if (m_identifier >= 0)
        return "SP: " + m_spacePoint->getName();
      else
        return "SP: missing";
    }
  };

}