GlobalLabel.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 <map>
#include <set>
 
namespace Belle2 {

  class GlobalLabel {
 
  public:
 
    typedef unsigned int gidTYPE;              
    static const gidTYPE maxPID     = 99;      
    static const gidTYPE maxEID     = 9999999; 
    static const gidTYPE maxTIF     = 1;       
    static const gidTYPE maxTEID    = 9999;    
    static const gidTYPE maxTID     = 999;     
    static const gidTYPE pidOffset  = 1;       
    static const gidTYPE eidOffest  = pidOffset * (maxPID + 1);  
    static const gidTYPE tifOffset  = eidOffest * (maxEID + 1);  
    static const gidTYPE teidOffset = eidOffest;                 
    static const gidTYPE tidOffset  = eidOffest * (maxTEID + 1); 
    static const gidTYPE maxGID     = pidOffset * maxPID + eidOffest * maxEID + tifOffset *
                                      maxTIF; 
    static const gidTYPE maxLabel   =
      maxGID;  

    GlobalLabel() {}

    explicit GlobalLabel(gidTYPE globalLabel);

    template<class DBObjType>
    static GlobalLabel construct(gidTYPE element, gidTYPE param)
    {
      GlobalLabel theLabel;
      theLabel.construct(DBObjType::getGlobalUniqueID(), element, param);
      return theLabel;
    }

    void construct(gidTYPE dbObjId, gidTYPE element, gidTYPE param)
    {
      if (m_components.empty() or m_components.find(dbObjId) != m_components.end())
        construct(100000 * dbObjId + element, param);
      else
        construct(0, 0);
    }

    static void setComponents(const std::set<unsigned short>& components)
    {
      m_components = components;
    }

    void registerTimeDependent(gidTYPE start, gidTYPE end = maxTID);

    gidTYPE setParameterId(gidTYPE paramId);

    int label() {return gid;}

    operator int() {return (int)label();}

    operator unsigned int() {return (unsigned int)label();}

    gidTYPE getUniqueId() const {return eid / 100000;}

    gidTYPE getElementId() const {return eid % 100000;}

    gidTYPE getParameterId() const {return pid;}

    gidTYPE getTimeId()      const {return tid;}

    bool    getTimeFlag()    const {return tif;}

    bool    isValid() {return 0 != gid;}

    void    dump(int level = 0) const;

    int     getEndOfValidity()
    {
      if (!tif)
        return maxTID;
      auto it = GlobalLabel::getTimeIntervals().find(makeEIDPID(eid, pid));
      if (it == GlobalLabel::getTimeIntervals().end())
        return tid;
      for (unsigned int i = tid; i < maxTID; i++) {
        if (it->second.get(i) != tid)
          return i - 1;
      }
      return tid;
    }

    static void clearTimeDependentParamaters();

    static unsigned int& getCurrentTimeIntervalRef()
    {
      static unsigned int subrun = 0;
      return subrun;
    }

    static void setCurrentTimeInterval(gidTYPE time)
    {
      gidTYPE& timeref = GlobalLabel::getCurrentTimeIntervalRef();
      timeref = time;
    }

    static gidTYPE getCurrentTimeInterval()
    {
      return GlobalLabel::getCurrentTimeIntervalRef();
    }
 
  private:
    static std::set<unsigned short> m_components;

    void construct(gidTYPE elementId, gidTYPE paramId);
 
  public:
    struct TimeInterval {
 
    private:

      gidTYPE teidpid_;

      gidTYPE arr_[maxTID + 1];
 
    public:

      TimeInterval(gidTYPE TEIDPID, gidTYPE start, gidTYPE end)
      {
        teidpid_ = TEIDPID;
        for (gidTYPE i = 0; i <= maxTID; i++) {
          if (i >= start && i <= end)
            arr_[i] = start;
          else
            arr_[i] = 0;
        }
      }

      gidTYPE teidpid() {return teidpid_;}

      gidTYPE get(gidTYPE timeid) {return arr_[timeid];}

      void set(gidTYPE start, gidTYPE end)
      {
        for (gidTYPE i = 0; i <= maxTID; i++) {
          if (i >= start && i <= end)
            arr_[i] = start;
        }
      }
    };
  public:
    static std::map<gidTYPE, TimeInterval >& getTimeIntervals()
    {
      // Map EIDPID -> (TEIDPID, time intervals)
      static std::map<gidTYPE, TimeInterval > intervals;
      return intervals;
    }

    static std::map<gidTYPE, gidTYPE>& getDictionary()
    {
      // Map TEIDPID -> EIDPID
      static std::map<gidTYPE, gidTYPE> dictionary;
      return dictionary;
    }

    gidTYPE makeEIDPID(gidTYPE eid_, gidTYPE pid_) {return pid_ * pidOffset + eid_ * eidOffest;}

    gidTYPE makeTEIDPID(gidTYPE teid_, gidTYPE pid_) {return pid_ * pidOffset + teid_ * teidOffset;}
  private:
    gidTYPE gid {0};

    gidTYPE eid {0};

    gidTYPE pid {0};

    gidTYPE tid {0};

    gidTYPE tif {0};
 
  };

}