TrajectoryPointFlags.h

Go to the documentation of this file.

#ifndef LARDATAOBJ_RECOBASE_TRAJECTORYPOINTFLAGS_H
#define LARDATAOBJ_RECOBASE_TRAJECTORYPOINTFLAGS_H

// LArSoft libraries
#include "lardataobj/Utilities/FlagSet.h"
#include "lardataobj/Utilities/BitMask.h"

// C/C++ standard libraries
#include <array>
#include <string>
#include <stdexcept> // std::out_of_range
#include <limits> // std::numeric_limits<>
#include <utility> // std::forward(), std::declval()
#include <iosfwd> // std::ostream
#include <cstddef> // std::size_t


namespace recob {
  
  
  struct TrajectoryPointFlagTraits {
    
    static constexpr unsigned int MaxFlags = 32;
    
    using Flags_t = util::flags::FlagSet<MaxFlags>;
    
    using Mask_t = Flags_t::Mask_t;
    
    using Flag_t = Flags_t::Flag_t;
    
    using FlagIndex_t = Flags_t::FlagIndex_t;
    

    static constexpr FlagIndex_t BeginTrajectoryFlags = 0;
    
    static constexpr Flag_t HitIgnored { 0 };
    
    static constexpr Flag_t NoPoint { 1 };
    
    static constexpr Flag_t Suspicious { 2 };
    
    static constexpr Flag_t Merged { 3 };
    
    static constexpr Flag_t DeltaRay { 4 };
    
    static constexpr Flag_t DetectorIssue { 5 };
    
    static constexpr Flag_t Shared { 6 };
    
    static constexpr Flag_t TrajReserved1 { 7 };
    
    static constexpr FlagIndex_t EndTrajectoryFlags = 8;
    
    //------------------------------------------------------------------------

    static constexpr FlagIndex_t BeginTrackFlags = EndTrajectoryFlags;
    
    static constexpr Flag_t ExcludedFromFit { 8 };
    
    static constexpr Flag_t Rejected { 9 };
    
    static constexpr Flag_t Reinterpreted { 10 };
    
    static constexpr Flag_t TrackReserved5 { 11 };
    
    static constexpr Flag_t TrackReserved4 { 12 };
    
    static constexpr Flag_t TrackReserved3 { 13 };
    
    static constexpr Flag_t TrackReserved2 { 14 };
    
    static constexpr Flag_t TrackReserved1 { 15 };
    
    static constexpr FlagIndex_t EndTrackFlags = 16;
    
    //------------------------------------------------------------------------
    
    static constexpr FlagIndex_t BeginExperimentReservedFlags = EndTrackFlags;
    
    static constexpr FlagIndex_t EndExperimentReservedFlags = 24;
    
    //------------------------------------------------------------------------
    
    static constexpr FlagIndex_t BeginUserReservedFlags
      = EndExperimentReservedFlags;
    
    static constexpr FlagIndex_t EndUserReservedFlags = 32;
    //------------------------------------------------------------------------
    
    
    static constexpr FlagIndex_t maxFlags() { return MaxFlags; }
    
    
    static constexpr bool isFlag(Flag_t flag)
      { return flag.index() < MaxFlags; }
    
    
    static std::string name(Flag_t flag)
      {
        return isFlag(flag)? names[flag.index()]: invalidFlagName(flag.index());
      }
    
    using NameMap_t = std::array<std::string, MaxFlags>;
    
    static NameMap_t initNames();
    
    
      private:
    static_assert(EndTrajectoryFlags <= BeginTrackFlags,
      "Too many trajectory flags");
    static_assert(EndTrackFlags <= BeginExperimentReservedFlags,
      "Too many track flags");
    static_assert(
      EndExperimentReservedFlags <= BeginUserReservedFlags,
      "Too many experiment-defined flags"
      );
    static_assert(EndUserReservedFlags <= MaxFlags,
      "Too many user-defined flags");
    
    static const NameMap_t names; 
    
    static std::string decorateFlagName(std::string baseName, Flag_t flag);

    static std::string invalidFlagName(Flag_t flag);
    
    static void initDefaultFlagRangeNames(
      NameMap_t& flagNames,
      FlagIndex_t BeginFlags, FlagIndex_t EndFlags, std::string baseName
      );
    
    static void initDefaultFlagsNames(NameMap_t& flagNames);
    
    static void setFlagNames(NameMap_t& flagNames);

  }; // class TrajectoryPointFlagTraits

  
  class TrajectoryPointFlags {
    
      public:
    
    using flag = TrajectoryPointFlagTraits;
    
    
    using Flags_t = flag::Flags_t; 
    
    using Mask_t = Flags_t::Mask_t; 
    
    using Flag_t = Flags_t::Flag_t; 
    
    using FlagIndex_t = Flags_t::FlagIndex_t; 
    
    using HitIndex_t = unsigned int; 
    
    
    static constexpr HitIndex_t InvalidHitIndex
      = std::numeric_limits<HitIndex_t>::max();
    
    
    constexpr TrajectoryPointFlags() = default;
    
    constexpr TrajectoryPointFlags(HitIndex_t fromHit)
      : fFromHit(fromHit)
      {}
     
    constexpr TrajectoryPointFlags
      (HitIndex_t fromHit, Mask_t flags)
      : fFromHit(fromHit)
      , fFlags(flags)
      {}
    
    template <typename... Flags>
    constexpr TrajectoryPointFlags(HitIndex_t fromHit, Flags... flags)
      : TrajectoryPointFlags(fromHit, makeMask(flags...))
      {}
    
    
    
    constexpr bool isAllocated(FlagIndex_t flagIndex) const
      { return flagIndex < flags().capacity(); }
    
    constexpr FlagIndex_t nFlags() const
      { return flag::maxFlags(); }
    
    constexpr bool isFlag(FlagIndex_t flagIndex) const
      { return flags().isFlag(flagIndex); }
    
    constexpr bool isFlag(Flag_t flag) const
      { return flags().isFlag(flag); }
    
    bool test(FlagIndex_t index) const
      { return flags().test(index); }
    
    bool test(Flag_t flag) const
      { return flags().test(flag); }
    
    
    bool get(Flag_t flag) const
      { return flags().get(flag); }
    
    
    bool isDefined(Flag_t flag) const
      { return flags().isDefined(flag); }
    
    bool isSet(Flag_t flag) const
      { return flags().isSet(flag); }
    
    bool isUnset(Flag_t flag) const
      { return flags().isUnset(flag); }
    
    bool match(Mask_t mask) const
      { return flags().match(mask); }
    
    
    
    
    constexpr Mask_t const& mask() const
      { return flags().mask(); }
    
    constexpr Flags_t const& flags() const
      { return fFlags; }
    
    

    bool anySet(Mask_t mask) const
      { return flags().anySet(mask); }
    
    bool noneSet(Mask_t mask) const
      { return flags().noneSet(mask); }
    
    
    
    
    
    bool isHitIgnored() const
      { return isSet(flag::HitIgnored); }
    
    bool isPointValid() const
      { return !isSet(flag::NoPoint); }
    
    bool isMerged() const
      { return isSet(flag::Merged); }
    
    bool isShared() const
      { return isSet(flag::Shared); }
    
    bool isDeltaRay() const
      { return isSet(flag::DeltaRay); }
    
    bool hasDetectorIssues() const
      { return isSet(flag::DetectorIssue); }
    
    bool isOtherwiseSuspicious() const
      { return isSet(flag::Suspicious); }
    
    bool isExclusive() const
      { return noneSet(SomehowSharedMask()); }
    
    bool isExcludedFromFit() const
      { return get(flag::ExcludedFromFit); }
    
    bool belongsToTrack() const
      { return !isSet(flag::Rejected); }
    
    bool isHitReinterpreted() const
      { return isSet(flag::Reinterpreted); }
    
    bool isIncludedInFit() const
      { return noneSet(ExcludedFromTrackFitMask()); }
    
    bool isPointFlawed() const
      { return anySet(ImperfectPointMask()); }
    
    bool isPointFlawless() const
      { return noneSet(ImperfectPointMask()); }
    
    
    
    constexpr bool hasOriginalHitIndex() const
      { return fromHit() != InvalidHitIndex; }
    
    
    constexpr HitIndex_t fromHit() const
      { return fFromHit; }
    
    
    
    constexpr bool operator== (TrajectoryPointFlags const& other) const;
    
    constexpr bool operator!= (TrajectoryPointFlags const& other) const;
    
    
    template <typename Stream>
    void dump(
      Stream&& out,
      unsigned int verbosity,
      std::string indent, std::string indentFirst
      ) const;
    
    template <typename Stream>
    void dump
      (Stream&& out, unsigned int verbosity = 1, std::string indent = {})
      const
      { dump(std::forward<Stream>(out), verbosity, indent, indent); }
    
    
    template <typename... Flags>
    static constexpr Mask_t makeMask(Flags... flags);
    
    static constexpr Mask_t DefaultFlagsMask();
    
      private:
    HitIndex_t fFromHit = InvalidHitIndex; 
    
    constexpr bool sameAs(TrajectoryPointFlags const& other) const;

    static constexpr Mask_t ImperfectPointMask();
    
    static constexpr Mask_t SomehowSharedMask();
    
    static constexpr Mask_t ExcludedFromTrackFitMask();
    
    Flags_t fFlags { DefaultFlagsMask() }; 
    
  }; // TrajectoryPointFlags<>
  
  
  std::ostream& operator<<
    (std::ostream& out, recob::TrajectoryPointFlags const& flags);
  
  
} // namespace recob


//------------------------------------------------------------------------------
//--- inline implementation
//---
template <typename... Flags>
inline constexpr recob::TrajectoryPointFlags::Mask_t
recob::TrajectoryPointFlags::makeMask(Flags... flags)
  { return Mask_t(flags...); }


//------------------------------------------------------------------------------
inline constexpr bool recob::TrajectoryPointFlags::sameAs
  (TrajectoryPointFlags const& other) const
  { return (flags() == other.flags()) && (fromHit() == other.fromHit()); }

inline constexpr bool recob::TrajectoryPointFlags::operator==
  (TrajectoryPointFlags const& other) const
  { return sameAs(other); }

inline constexpr bool recob::TrajectoryPointFlags::operator!=
  (TrajectoryPointFlags const& other) const
  { return !sameAs(other); }


//------------------------------------------------------------------------------
inline constexpr recob::TrajectoryPointFlags::Mask_t
recob::TrajectoryPointFlags::ImperfectPointMask() {
  return flag::NoPoint + flag::HitIgnored
    + flag::Suspicious
    + flag::Merged + flag::DeltaRay + flag::DetectorIssue + flag::Shared
    ;
} // recob::TrajectoryPointFlags::ImperfectPointMask()

inline constexpr recob::TrajectoryPointFlags::Mask_t
recob::TrajectoryPointFlags::SomehowSharedMask()
  { return flag::Merged + flag::DeltaRay + flag::Shared; }

inline constexpr recob::TrajectoryPointFlags::Mask_t
recob::TrajectoryPointFlags::ExcludedFromTrackFitMask()
  { return flag::ExcludedFromFit + flag::Rejected; }


//------------------------------------------------------------------------------
inline constexpr typename recob::TrajectoryPointFlags::Mask_t
recob::TrajectoryPointFlags::DefaultFlagsMask() {
  return makeMask( -flag::NoPoint );
} // recob::TrajectoryPointFlags::DefaultFlagsMask()


//------------------------------------------------------------------------------
//--- template implementation
//---
  
#include "TrajectoryPointFlags.tcc"

//------------------------------------------------------------------------------

#endif // LARDATAOBJ_RECOBASE_TRAJECTORYPOINTFLAGS_H