AutomatonCell.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/trackFindingCDC/numerics/Weight.h>
 
namespace Belle2 {
  namespace TrackFindingCDC {
 
    class AutomatonCell {
 
    public:
      enum ECellFlag : unsigned int {
        c_Assigned = 1,
        c_Start = 2,
        c_PriorityPath = 4,
        c_Cycle = 8,
 
        c_Masked = 16,
 
        c_Taken = 32,
        c_Background = 64,
        c_Priority = 128,
        c_Reverse = 256,
        c_Alias = 512,
        c_BadADCOrTOT = 1024, // A CDCWireHit with bad ADC or TOT should not be used in pattern recognition.
      };
 
      using ECellFlags = ECellFlag;
 
      static const ECellFlags c_AllFlags = ECellFlags(ECellFlag::c_Assigned +
                                                      ECellFlag::c_Start +
                                                      ECellFlag::c_PriorityPath +
                                                      ECellFlag::c_Cycle +
                                                      ECellFlag::c_Masked +
                                                      ECellFlag::c_Taken +
                                                      ECellFlag::c_Background +
                                                      ECellFlag::c_Reverse +
                                                      ECellFlag::c_Alias +
                                                      ECellFlag::c_BadADCOrTOT);
 
      static const ECellFlags c_TemporaryFlags = ECellFlags(ECellFlag::c_Assigned +
                                                            ECellFlag::c_Start +
                                                            ECellFlag::c_PriorityPath +
                                                            ECellFlag::c_Cycle);
 
    public:
      AutomatonCell()
        : m_weight(0)
        , m_flags(ECellFlag(0))
        , m_state(0)
      {
      }
 
      explicit AutomatonCell(const Weight& cellWeight)
        : m_weight(cellWeight)
        , m_flags(ECellFlag(0))
        , m_state(0)
      {
      }
 
      AutomatonCell(const Weight& cellWeight, const ECellFlags& initialFlags)
        : m_weight(cellWeight)
        , m_flags(initialFlags)
        , m_state(0)
      {
      }
 
      Weight getCellState() const
      {
        return m_state;
      }
 
      void setCellState(Weight state)
      {
        m_state = state;
      }
 
      Weight getCellWeight() const
      {
        return m_weight;
      }
 
      void setCellWeight(Weight weight)
      {
        m_weight = weight;
      }
 
      void setAssignedFlag(bool setTo = true)
      {
        setFlags<ECellFlag::c_Assigned>(setTo);
      }
 
      void unsetAssignedFlag()
      {
        setFlags<ECellFlag::c_Assigned>(false);
      }
 
      bool hasAssignedFlag() const
      {
        return hasAnyFlags(ECellFlag::c_Assigned);
      }
 
      void setStartFlag(bool setTo = true)
      {
        setFlags<ECellFlag::c_Start>(setTo);
      }
 
      void unsetStartFlag()
      {
        setFlags<ECellFlag::c_Start>(false);
      }
 
      bool hasStartFlag() const
      {
        return hasAnyFlags(ECellFlag::c_Start);
      }
 
      void setPriorityPathFlag(bool setTo = true)
      {
        setFlags<ECellFlag::c_PriorityPath>(setTo);
      }
 
      void unsetPriorityPathFlag()
      {
        setFlags<ECellFlag::c_PriorityPath>(false);
      }
 
      bool hasPriorityPathFlag() const
      {
        return hasAnyFlags(ECellFlag::c_PriorityPath);
      }
 
      void setCycleFlag(bool setTo = true)
      {
        setFlags<ECellFlag::c_Cycle>(setTo);
      }
 
      void unsetCycleFlag()
      {
        setFlags<ECellFlag::c_Cycle>(false);
      }
 
      bool hasCycleFlag() const
      {
        return hasAnyFlags(ECellFlag::c_Cycle);
      }
 
      void unsetTemporaryFlags()
      {
        setFlags<c_TemporaryFlags>(false);
      }
 
      void setMaskedFlag(bool setTo = true)
      {
        setFlags<ECellFlag::c_Masked>(setTo);
      }
 
      void unsetMaskedFlag()
      {
        setFlags<ECellFlag::c_Masked>(false);
      }
 
      bool hasMaskedFlag() const
      {
        return hasAnyFlags(ECellFlag::c_Masked);
      }
 
      void setTakenFlag(bool setTo = true)
      {
        setFlags<ECellFlag::c_Taken>(setTo);
      }
 
      void unsetTakenFlag()
      {
        setFlags<ECellFlag::c_Taken>(false);
      }
 
      bool hasTakenFlag() const
      {
        return hasAnyFlags(ECellFlag::c_Taken);
      }
 
      void setBackgroundFlag(bool setTo = true)
      {
        setFlags<ECellFlag::c_Background>(setTo);
      }
 
      void unsetBackgroundFlag()
      {
        setFlags<ECellFlag::c_Background>(false);
      }
 
      bool hasBackgroundFlag() const
      {
        return hasAnyFlags(ECellFlag::c_Background);
      }
 
      void setBadADCOrTOTFlag(bool setTo = true)
      {
        setFlags<ECellFlag::c_BadADCOrTOT>(setTo);
      }
 
      void unsetBadADCOrTOTFlag()
      {
        setFlags<ECellFlag::c_BadADCOrTOT>(false);
      }
 
      bool hasBadADCOrTOTFlag() const
      {
        return hasAnyFlags(ECellFlag::c_BadADCOrTOT);
      }
 
      void setPriorityFlag(bool setTo = true)
      {
        setFlags<ECellFlag::c_Priority>(setTo);
      }
 
      void unsetPriorityFlag()
      {
        setFlags<ECellFlag::c_Priority>(false);
      }
 
      bool hasPriorityFlag() const
      {
        return hasAnyFlags(ECellFlag::c_Priority);
      }
 
      void setReverseFlag(bool setTo = true)
      {
        setFlags<ECellFlag::c_Reverse>(setTo);
      }
 
      void unsetReverseFlag()
      {
        setFlags<ECellFlag::c_Reverse>(false);
      }
 
      bool hasReverseFlag() const
      {
        return hasAnyFlags(ECellFlag::c_Reverse);
      }
 
      void setAliasFlag(bool setTo = true)
      {
        setFlags<ECellFlag::c_Alias>(setTo);
      }
 
      void unsetAliasFlag()
      {
        setFlags<ECellFlag::c_Alias>(false);
      }
 
      bool hasAliasFlag() const
      {
        return hasAnyFlags(ECellFlag::c_Alias);
      }
 
      template<ECellFlags cellFlag>
      void setFlags(bool setTo)
      {
        if (setTo) {
          setFlags(cellFlag);
        } else {
          clearFlags(cellFlag);
        }
      }
 
      const ECellFlags& getFlags() const
      { return m_flags; }
 
      void setFlags(ECellFlags flags)
      { m_flags = ECellFlags(m_flags bitor flags); }
 
      void clearFlags(ECellFlags flags = c_AllFlags)
      { m_flags = ECellFlags(m_flags bitand ~flags); }
 
      bool hasAnyFlags(ECellFlags flags) const
      { return  m_flags bitand flags; }
 
    private:
      Weight m_weight = 1;
 
      ECellFlags m_flags = ECellFlag(0);
 
      Weight m_state = 0;
    };
  }
}