TrajectoryPointFlags.h

Go to the documentation of this file.

#ifndef LARDATAOBJ_RECOBASE_TRAJECTORYPOINTFLAGS_H
#define LARDATAOBJ_RECOBASE_TRAJECTORYPOINTFLAGS_H

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

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

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