BmnEnums.h

Go to the documentation of this file.

/**
 * \file BmnEnums.h
 * \author Andrey Lebedev <andrey.lebedev@gsi.de> - Original author. First version of code for CBM experiment.
 * \author Sergey Merts <Sergey.Merts@gmail.com> - Modification for BMN experiment.
 * \date 2008-2014
 * \brief Define enumerations used in tracking.
 **/
 
#ifndef BMNENUMS_H_
#define BMNENUMS_H_
 
#include <cstddef>
#include <type_traits>
 
/*
 * A preprocessor definition to make an enumeration type a bitmask.
 * If not familiar with bitmasks, see "C++ named requirements: BitmaskType" on cppreference (link:
 * https://cppreference.dev/w/cpp/named_req/BitmaskType)
 */
#define MAKE_ENUM_BITMASK(EnumType)                                                                       \
    inline EnumType& operator|=(EnumType& lhv, const EnumType rhv)                                        \
    {                                                                                                     \
        lhv = (EnumType)((std::underlying_type_t<EnumType>)lhv | (std::underlying_type_t<EnumType>)rhv);  \
        return lhv;                                                                                       \
    }                                                                                                     \
    inline EnumType& operator&=(EnumType& lhv, const EnumType rhv)                                        \
    {                                                                                                     \
        lhv = (EnumType)((std::underlying_type_t<EnumType>)lhv & (std::underlying_type_t<EnumType>)rhv);  \
        return lhv;                                                                                       \
    }                                                                                                     \
    inline EnumType& operator^=(EnumType& lhv, const EnumType rhv)                                        \
    {                                                                                                     \
        lhv = (EnumType)((std::underlying_type_t<EnumType>)lhv ^ (std::underlying_type_t<EnumType>)rhv);  \
        return lhv;                                                                                       \
    }                                                                                                     \
    constexpr EnumType operator|(const EnumType lhv, const EnumType rhv)                                  \
    {                                                                                                     \
        return (EnumType)((std::underlying_type_t<EnumType>)lhv | (std::underlying_type_t<EnumType>)rhv); \
    }                                                                                                     \
    constexpr EnumType operator&(const EnumType lhv, const EnumType rhv)                                  \
    {                                                                                                     \
        return (EnumType)((std::underlying_type_t<EnumType>)lhv & (std::underlying_type_t<EnumType>)rhv); \
    }                                                                                                     \
    constexpr EnumType operator^(const EnumType lhv, const EnumType rhv)                                  \
    {                                                                                                     \
        return (EnumType)((std::underlying_type_t<EnumType>)lhv ^ (std::underlying_type_t<EnumType>)rhv); \
    }                                                                                                     \
    constexpr EnumType operator~(const EnumType value)                                                    \
    {                                                                                                     \
        return (EnumType)(~((std::underlying_type_t<EnumType>)value));                                    \
    }
 
/*
 * Checks if an enumeration-type argument has at least one of the provided flags (for bitmasks)
 * @tparam T An enumeration type
 * @param lhv An enumeration-type argument for which one wants to check the existence of some flags from `rhv`
 * @param rhv Enumeration-type values one is looking for in the `lhv` argument
 * @return 'true' if the enum argument has some of the provided flags, or 'false' if it doesn't
 */
template<typename T>
inline auto HasAnyFlags(const T lhv, const T rhv) -> std::enable_if_t<std::is_enum_v<T>, bool>
{
    return (std::underlying_type_t<T>)(lhv & rhv) != 0 ? true : false;
}
 
/*
 * Checks if an enumeration-type argument has all of the provided flags (for bitmasks)
 * @tparam T An enumeration type
 * @param lhv An enumeration-type argument for which one wants to check the existence of all the flags from `rhv`
 * @param rhv Enumeration-type values one is looking for in the `lhv` argument
 * @return 'true' if the enum argument has all of the provided flags, or 'false' if it doesn't
 */
template<typename T>
inline auto HasAllFlags(const T lhv, const T rhv) -> std::enable_if_t<std::is_enum_v<T>, bool>
{
    return ((lhv & rhv) == rhv) ? true : false;
}
 
/**
 * Define type of hit on detector station.
 */
enum BmnHitType
{
    kBMNSTRIPHIT = 0, /**< Strip hit. */
    kBMNPIXELHIT = 1, /**< Pixel hit. */
    kBMNMIXHIT = 2    /**< Mixed type of hits, i.e. both strip and pixel hits. **/
};
 
/**
 * Define status code.
 */
enum BmnStatus
{
    kBMNSUCCESS = 0, /**< Success. */
    kBMNERROR = 1,   /**< Error. */
    kBMNTIMEOUT = 2,
    kBMNFINISH = 3,
    kBMNCONTINUE = 4
};
 
/**
 * Define reconstructed track quality.
 */
enum BmnTrackQa
{
    kBMNGOOD = 0,     /**< Good track. */
    kBMNBAD = 1,      /**< Bad track. */
    kBMNGOODMERGE = 2 /**< Correctly merged track. */
};
 
/**
 * Define system identificator.
 */
enum BmnSystemId
{
    kBMNGEM = 0, /**< GEM detector. */
    kBMNTOF = 2, /**< TOF detector. */
    kBMNSTS = 4  /**< STS detector. */
};
 
/**
 * Define status of TOF hit merging
 */
enum BmnTofHitQA
{
    kBMNTOFGOOD = 0, /**< merged TOF hit. */
    kBMNTOFBAD = 1,  /**< not merged TOF hit. */
};
 
/**
 * Define type of event
 */
enum BmnTriggerType
{
    kBMNBEAM = 6,    /**< "beam"  BC1 + BC2 + T0 + VC */
    kBMNMINBIAS = 1, /**< "min.bias" BC1 + BC2 + T0 + VC + FD */
};
 
/**
 * Define type of event
 */
enum BmnEventType
{
    kBMNPEDESTAL = 0, /**< pedestal event. */
    kBMNPAYLOAD = 1,  /**< spill event. */
    kBMNEOS = 2,      /**< End of spill. */
    kBMNSTAT = 3,     /**< Statistics. */
    kBMNEMPTY = 4,    /**< No event (wrong sync word or metadata payload) */
};
 
/**
 * Define worker state
 */
enum BmnWorkerState
{
    kBMNWAIT = 0,
    kBMNWORK = 1,
    kBMNRECON = 2,
};
 
/**
 * Define experimental setup
 */
enum BmnSetup
{
    kBMNSETUP = 0,
    kSRCSETUP = 1,
};
 
#endif /* BMNENUMS_H_ */