L1GtDefinitions.cc

Go to the documentation of this file.

// this class header
#include "CondFormats/L1TObjects/interface/L1GtDefinitions.h"

// system include files
#include <cstring>

// user include files
#include "FWCore/MessageLogger/interface/MessageLogger.h"
namespace {
template <class T>
struct entry {                                                                                                                                                    
  char const* label;
  T           value;
};

constexpr bool same(char const *x, char const *y) {
  return !*x && !*y     ? true                                                                                                                                
       : /* default */    (*x == *y && same(x+1, y+1));                                                                                                       
}

template <class T>
constexpr T keyToValue(char const *label, entry<T> const *entries) {                                                                                  
  return !entries->label ? entries->value                         
       : same(entries->label, label) ? entries->value
       : /*default*/                   keyToValue(label, entries+1);                                                                                 
}

template <class T>
constexpr char const*valueToKey(T value, entry<T> const *entries) {
  return !entries->label ? entries->label
       : entries->value == value ? entries->label
       : /*default*/       valueToKey(value, entries+1);
}
constexpr entry<L1GtBoardType> l1GtBoardTypeStringToEnumMap[] = {
            {"GTFE", GTFE},
            {"FDL", FDL},
            {"PSB", PSB},
            {"GMT", GMT},
            {"TCS", TCS},
            {"TIM", TIM},
            {"BoardNull", BoardNull},
            {0, (L1GtBoardType)-1}
};

constexpr entry<L1GtPsbQuad> l1GtPsbQuadStringToEnumMap[] = {
        {"Free", Free},
        {"TechTr", TechTr},
        {"IsoEGQ", IsoEGQ},
        {"NoIsoEGQ", NoIsoEGQ},
        {"CenJetQ", CenJetQ},
        {"ForJetQ", ForJetQ},
        {"TauJetQ", TauJetQ},
        {"ESumsQ", ESumsQ},
        {"JetCountsQ", JetCountsQ},
        {"MQB1", MQB1},
        {"MQB2", MQB2},
        {"MQF3", MQF3},
        {"MQF4", MQF4},
        {"MQB5", MQB5},
        {"MQB6", MQB6},
        {"MQF7", MQF7},
        {"MQF8", MQF8},
        {"MQB9", MQB9},
        {"MQB10", MQB10},
        {"MQF11", MQF11},
        {"MQF12", MQF12},
        {"CastorQ", CastorQ},
        {"HfQ", HfQ},
        {"BptxQ", BptxQ},
        {"GtExternalQ", GtExternalQ},
        {"PsbQuadNull", PsbQuadNull},
        {0, (L1GtPsbQuad) - 1}
};

// L1GtConditionType
constexpr entry<L1GtConditionType> l1GtConditionTypeStringToEnumMap[] = {
        {"TypeNull", TypeNull},
        {"Type1s", Type1s},
        {"Type2s", Type2s},
        {"Type2wsc", Type2wsc},
        {"Type2cor", Type2cor},
        {"Type3s", Type3s},
        {"Type4s", Type4s},
        {"TypeETM", TypeETM},
        {"TypeETT", TypeETT},
        {"TypeHTT", TypeHTT},
        {"TypeHTM", TypeHTM},
        {"TypeJetCounts", TypeJetCounts},
        {"TypeCastor", TypeCastor},
        {"TypeHfBitCounts", TypeHfBitCounts},
        {"TypeHfRingEtSums", TypeHfRingEtSums},
        {"TypeBptx", TypeBptx},
        {"TypeExternal", TypeExternal},
        {0, (L1GtConditionType) - 1}
};

// L1GtConditionCategory
constexpr entry<L1GtConditionCategory> l1GtConditionCategoryStringToEnumMap[] = {
  {"CondNull", CondNull},
  {"CondMuon", CondMuon},
  {"CondCalo", CondCalo},
  {"CondEnergySum", CondEnergySum},
  {"CondJetCounts", CondJetCounts},
  {"CondCorrelation", CondCorrelation},
  {"CondCastor", CondCastor},
  {"CondHfBitCounts", CondHfBitCounts},
  {"CondHfRingEtSums", CondHfRingEtSums},
  {"CondBptx", CondBptx},
  {"CondExternal", CondExternal},
  {0, (L1GtConditionCategory) - 1}
};

}
// L1GtBoardType
L1GtBoardType l1GtBoardTypeStringToEnum(const std::string& label) {
    L1GtBoardType value = keyToValue(label.c_str(), l1GtBoardTypeStringToEnumMap);
    if (value == (L1GtBoardType) - 1) {
        edm::LogInfo("L1GtDefinitions") << "\n  '" << label
                << "' is not a recognized L1GtBoardType. \n  Return BoardNull.";
        value = BoardNull;
    }

    if (value == BoardNull) {
        edm::LogInfo("L1GtDefinitions")
                << "\n  BoardNull means no valid board type defined!";
    }

    return value;
}

std::string l1GtBoardTypeEnumToString(const L1GtBoardType& boardType) {
    char const *result= valueToKey(boardType, l1GtBoardTypeStringToEnumMap);
    if (boardType == BoardNull) {
        edm::LogInfo("L1GtDefinitions")
                << "\n  BoardNull means no valid board type defined!";
    }
    if (!result) {
      edm::LogInfo("L1GtDefinitions") << "\n  '" << boardType
                  << "' is not a recognized L1GtBoardType. "
                  << "\n  Return BoardNull, which means no valid board type defined!";
      return "BoardNull";
    }
    return result;
}


// L1GtPsbQuad

L1GtPsbQuad l1GtPsbQuadStringToEnum(const std::string& label) {
    L1GtPsbQuad value = keyToValue(label.c_str(), l1GtPsbQuadStringToEnumMap);
    // in case of unrecognized L1GtPsbQuad, return PsbQuadNull
    // to be dealt by the corresponding module
    if (value == -1) {
        edm::LogInfo("L1GtDefinitions") << "\n  '" << label
                << "' is not a recognized L1GtPsbQuad. \n  Return PsbQuadNull.";
        value = PsbQuadNull;
    }

    if (value == PsbQuadNull) {
        edm::LogInfo("L1GtDefinitions")
                << "\n  PsbQuadNull means no valid PSB quadruplet defined!";
    }

    return value;
}

std::string l1GtPsbQuadEnumToString(const L1GtPsbQuad& psbQuad) {
  char const*result = valueToKey(psbQuad, l1GtPsbQuadStringToEnumMap);
  if (psbQuad == PsbQuadNull)
    edm::LogInfo("L1GtDefinitions") << "\n  PsbQuadNull means no valid PSB quadruplet defined!";
  if (!result) {
    result = "PsbQuadNull";
    edm::LogInfo("L1GtDefinitions") << "\n  '" << psbQuad
                 << "' is not a recognized L1GtPsbQuad. "
                 << "\n  Return PsbQuadNull, which means no valid PSB quadruplet defined!";
  }

  return result;
}


L1GtConditionType l1GtConditionTypeStringToEnum(const std::string& label) {
    L1GtConditionType value = keyToValue(label.c_str(), l1GtConditionTypeStringToEnumMap);

    // in case of unrecognized L1GtConditionType, return TypeNull
    // to be dealt by the corresponding module
    if (value == (L1GtConditionType) -1) {
        edm::LogInfo("L1GtDefinitions")  << "\n  '" << label
                << "' is not a recognized L1GtConditionType. \n  Return TypeNull.";

        value = TypeNull;
    }

    if (value == TypeNull) {
        edm::LogInfo("L1GtDefinitions")
                << "\n  TypeNull means no valid condition type defined!";
    }

    return value;
}

std::string l1GtConditionTypeEnumToString(const L1GtConditionType& conditionType) {
  const char *result = valueToKey(conditionType, l1GtConditionTypeStringToEnumMap);
  if (conditionType == TypeNull)
    edm::LogInfo("L1GtDefinitions") 
      << "\n  Return TypeNull, which means no valid condition type defined!";
  if (!result) {
    result = "TypeNull";
    edm::LogInfo("L1GtDefinitions") << "\n  '" << conditionType
            << "' is not a recognized L1GtConditionType. "
            << "\n  Return TypeNull, which means no valid condition type defined!";
  }
  return result;
}

L1GtConditionCategory l1GtConditionCategoryStringToEnum(const std::string& label) {
  L1GtConditionCategory value = keyToValue(label.c_str(), l1GtConditionCategoryStringToEnumMap);
  // in case of unrecognized L1GtConditionCategory, return CondNull
  // to be dealt by the corresponding module
  if (value == (L1GtConditionCategory) -1) {
    edm::LogInfo("L1GtDefinitions") << "\n  '" << label
            << "' is not a recognized L1GtConditionCategory. \n  Return CondNull.";

    value = CondNull;
  }

  if (value == CondNull) {
      edm::LogInfo("L1GtDefinitions")
              << "\n  CondNull means no valid condition category defined!";
  }

  return value;
}

std::string l1GtConditionCategoryEnumToString(const L1GtConditionCategory& conditionCategory) {
  char const *result = valueToKey(conditionCategory, l1GtConditionCategoryStringToEnumMap);
  if (conditionCategory == CondNull)
    edm::LogInfo("L1GtDefinitions")
            << "\n  Return CondNull, which means no valid condition category defined!";
    
  if (!result) {
    result = "CondNull";
    edm::LogInfo("L1GtDefinitions") << "\n  '" << conditionCategory
            << "' is not a recognized L1GtConditionCategory. "
            << "\n  Return CondNull, which means no valid condition category defined!";
  }

  return result;
}