Sector.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
 
// includes - rootStuff:
// includes - stl:
#include <vector>
#include <string>
 
// includes - tf-related stuff
// includes - general fw stuff
#include <framework/datastore/RelationsObject.h>
 
 
namespace Belle2 {
  class ActivatedSector;
 
 
  class SectorFriendship;
 
 
  class Sector : public RelationsObject {
  public:
 
 
    Sector():
      m_myActiveSector(nullptr),
      m_sectorID(0),
      m_distance2Origin(0),
      m_useDistance4sort(false)
    {}
 
 
    explicit Sector(unsigned int secID):
      m_myActiveSector(nullptr),
      m_sectorID(secID),
      m_distance2Origin(0),
      m_useDistance4sort(false)
    {}
 
 
    Sector(unsigned int secID, float distance2origin, bool sortByDistance = true):
      m_myActiveSector(nullptr),
      m_sectorID(secID),
      m_distance2Origin(distance2origin),
      m_useDistance4sort(sortByDistance)
    {}
 
    Sector(const Sector&) = default;
 
 
    Sector& operator=(const Sector& aSector)
    {
      m_myActiveSector = aSector.getMyActiveSector();
      m_sectorID = aSector.getSecID();
      m_distance2Origin = aSector.getDistance();
      m_useDistance4sort = aSector.useDistance4sort();
      return *this;
    }
 
 
    bool operator<(const Sector& b)  const
    {
      if (m_useDistance4sort == false) { return getSecID() < b.getSecID(); }
      return getDistance() < b.getDistance();
    }
 
 
    bool operator==(const Sector& b) const
    {
      if (useDistance4sort() == false) { return getSecID() == b.getSecID(); }
      return getDistance() == b.getDistance();
    }
 
 
    bool operator>(const Sector& b)  const
    {
      if (useDistance4sort() == false) { return getSecID() > b.getSecID(); }
      return getDistance() > b.getDistance();
    }
 
 
    void segmentMaker();
 
 
    virtual void clear() { m_myActiveSector = nullptr; }
 
 
    ActivatedSector* getMyActiveSector() const { return m_myActiveSector; }
 
 
    void setDistance(float distance) { m_distance2Origin = distance; }
 
 
    float getDistance() const { return m_distance2Origin; }
 
 
    unsigned getSecID() const { return m_sectorID; }
 
 
    std::string printSector();
 
 
    bool useDistance4sort() const { return m_useDistance4sort; }
 
 
    void setDistance4sort(bool sortByDistance) { m_useDistance4sort = sortByDistance; }
 
 
  protected:
 
 
    ActivatedSector* m_myActiveSector;
 
 
    std::vector<SectorFriendship*> m_myFriends;
 
 
    unsigned int m_sectorID;
 
 
    float m_distance2Origin;
 
 
    bool m_useDistance4sort;
 
 
    ClassDef(Sector, 1)
  };
} //Belle2 namespace