FlagwordDefinitions.h

#ifndef FLAGWORDDEFINITIONS_H
#define FLAGWORDDEFINITIONS_H

namespace marlintpc
{

  namespace pulseflag
  {
    int const MULTIPLE_PULSE_CANDIDATE_BIT = 1;
    int const ANOMALOUS_SHAPE_BIT          = 1 << 1;
    int const OVERFLOW_BIN_BIT             = 1 << 2;
    int const UNDERFLOW_BIN_BIT            = 1 << 3;
    int const WAS_SPLIT_BIT                = 1 << 4;
    int const PLATEAU_CUTOFF_BIT           = 1 << 5;

    inline void setMultiplePulseCandidate(int& i)
    {
      i |= MULTIPLE_PULSE_CANDIDATE_BIT;
    }
    inline void setAnomalousShape(int& j)
    {
      j |= ANOMALOUS_SHAPE_BIT;
    }
    inline void setOverflow(int& k)
    {
      k |= OVERFLOW_BIN_BIT;
    }
    inline void setUnderflow(int& m)
    {
      m |= UNDERFLOW_BIN_BIT;
    }
    inline void setSplit(int& n)
    {
      n |= WAS_SPLIT_BIT;
    }
    inline void setPlateauCutoff(int& l)
    {
      l |= PLATEAU_CUTOFF_BIT;
    }


    inline bool isMultiplePulseCandidate(int i)
    {
      return i & MULTIPLE_PULSE_CANDIDATE_BIT;
    }
    inline bool isAnomalousShape(int j)
    {
      return j & ANOMALOUS_SHAPE_BIT;
    }
    inline bool isOverflow(int k)
    {
      return k & OVERFLOW_BIN_BIT;
    }
    inline bool isUnderflow(int m)
    {
      return m & UNDERFLOW_BIN_BIT;
    }
    inline bool isSplit(int n)
    {
      return n & WAS_SPLIT_BIT;
    }
    inline bool isPlateauCutoff(int l)
    {
      return l & PLATEAU_CUTOFF_BIT;
    }


  }


  namespace hitflag
  {
    int const CONTAINS_DEAD_CHANNEL_BIT     = 1;
    int const CONTAINS_NOISY_CHANNEL_BIT    = 1 << 1;
    int const HIT_AT_MODULE_BORDER_BIT      = 1 << 2;
    int const CONTAINS_OVERFLOW_PULSE_BIT   = 1 << 3;
    int const CONTAINS_SPLIT_PULSE_BIT      = 1 << 4;
    int const CONTAINS_ANOMALOUS_PULSE_BIT  = 1 << 5;
    int const HIT_NEXT_TO_DEAD_CHANNEL_BIT  = 1 << 6;
    int const MULTIPLE_HIT_CANDIDATE_BIT    = 1 << 7;
    int const REMOVE_FROM_TRACK_FINDING_BIT = 1 << 8;
    int const CONTAINS_PLATEAU_CUTOFF_PULSE_BIT  = 1 << 9;
 
    inline void setDeadChannel(int& i)
    {
      i |= CONTAINS_DEAD_CHANNEL_BIT;
    }
    inline void setNoisyChannel(int& j)
    {
      j |= CONTAINS_NOISY_CHANNEL_BIT;
    }
    inline void setAtModuleBorder(int& k)
    {
      k |= HIT_AT_MODULE_BORDER_BIT;
    }
    inline void setOverflowPulse(int& m)
    {
      m |= CONTAINS_OVERFLOW_PULSE_BIT;
    }
    inline void setSplitPulse(int& n)
    {
      n |= CONTAINS_SPLIT_PULSE_BIT;
    }
    inline void setAnomalousPulseShape(int& p)
    {
      p |= CONTAINS_ANOMALOUS_PULSE_BIT;
    }
    inline void setNextToDeadChannel(int& q)
    {
      q |= HIT_NEXT_TO_DEAD_CHANNEL_BIT;
    }
    inline void setMultipleHitCandidate(int& r)
    {
      r |= MULTIPLE_HIT_CANDIDATE_BIT;
    }
    inline void setRemoveFromTrackFinding(int& s)
    {
      s |= REMOVE_FROM_TRACK_FINDING_BIT;
    }
    inline void setPlateauCutoffPulse(int& t)
    {
      t |= CONTAINS_PLATEAU_CUTOFF_PULSE_BIT;
    }

    inline bool hasDeadChannel(int i)
    {
      return i & CONTAINS_DEAD_CHANNEL_BIT;
    }
    inline bool hasNoisyChannel(int j)
    {
      return j & CONTAINS_NOISY_CHANNEL_BIT;
    }
    inline bool isAtModuleBorder(int k)
    {
      return k & HIT_AT_MODULE_BORDER_BIT;
    }
    inline bool hasOverflowPulse(int m)
    {
      return m & CONTAINS_OVERFLOW_PULSE_BIT;
    }
    inline bool hasSplitPulse(int n)
    {
      return n & CONTAINS_SPLIT_PULSE_BIT;
    }
    inline bool hasAnomalousPulseShape(int p)
    {
      return p & CONTAINS_ANOMALOUS_PULSE_BIT;
    }
    inline bool isNextToDeadChannel(int q)
    {
      return q & HIT_NEXT_TO_DEAD_CHANNEL_BIT;
    }
    inline bool isMultipleHitCandidate(int r)
    {
      return r & MULTIPLE_HIT_CANDIDATE_BIT;
    }
    inline bool isRemovedFromTrackFinding(int s)
    {
        return s & REMOVE_FROM_TRACK_FINDING_BIT;
    }
    inline bool hasPlateauCutoffPulse(int t)
    {
        return t & CONTAINS_PLATEAU_CUTOFF_PULSE_BIT;
    }
  }

  namespace trackflag
  {

    int const HELIX_TRACKMODEL_BIT         = 1 ;
    int const STRAIGHT_LINE_TRACKMODEL_BIT = 1 << 1;
    int const MULTIPLE_TRACK_CANDIDATE_BIT = 1 << 2;
    int const BROKEN_LINE_FITTER_BIT   = 1 << 7;
    int const CHISQUARE_FITTER_BIT         = 1 << 8;
    int const KALMAN_FITTER_BIT            = 1 << 9;
    int const LIKELIHOOD_FITTER_BIT        = 1 << 10;

    inline void setHelixTrackModel(int& i)
    {
      i |= HELIX_TRACKMODEL_BIT;
    }
    inline void setStraightLineTrackModel(int& j)
    {
      j |= STRAIGHT_LINE_TRACKMODEL_BIT;
    }
    inline void setMultipleTrackCandidate(int& j)
    {
      j |= MULTIPLE_TRACK_CANDIDATE_BIT;
    }
    inline void setBrokenLineFitter(int& j)
    {
      j |= BROKEN_LINE_FITTER_BIT;
    }
    inline void setChiSquareFitter(int& j)
    {
      j |= CHISQUARE_FITTER_BIT;
    }
    inline void setKalmanFitter(int& j)
    {
      j |= KALMAN_FITTER_BIT;
    }
    inline void setLikelihoodFitter(int& j)
    {
      j |= LIKELIHOOD_FITTER_BIT;
    }

    inline bool isHelixTrackModel(int i)
    {
      return i & HELIX_TRACKMODEL_BIT;
    }
    inline bool isStraightLineTrackModel(int j)
    {
      return j & STRAIGHT_LINE_TRACKMODEL_BIT;
    }
    inline bool isMultipleTrackCandidate(int j)
    {
      return j & MULTIPLE_TRACK_CANDIDATE_BIT;
    }
    inline bool isBrokenLineFitter(int j)
    {
      return j & BROKEN_LINE_FITTER_BIT;
    }
    inline bool isChiSquareFitter(int j)
    {
      return  j & CHISQUARE_FITTER_BIT;
    }
    inline bool isKalmanFitter(int j)
    {
      return j & KALMAN_FITTER_BIT;
    }
    inline bool isLikelihoodFitter(int j)
    {
      return j & LIKELIHOOD_FITTER_BIT;
    }
  }
}


#endif //FLAGWORDDEFINITIONS_H