TCType.h

/**************************************************************************
 * BASF2 (Belle Analysis Framework 2)                                     *
 * Copyright(C) 2015 - Belle II Collaboration                             *
 *                                                                        *
 * Author: The Belle II Collaboration                                     *
 * Contributors: Jakob Lettenbichler                                      *
 *                                                                        *
 * This software is provided "as is" without any warranty.                *
 **************************************************************************/
#pragma once
 
// framework:
#include <framework/logging/Logger.h>
 
// stl:
#include <string>
#include <map>
 
 
 
namespace Belle2 {
  class TCType {
  public:
 
    enum Type {
      UnknownType, // the type of this TC is not even unclassified but completely unknown, normally a hint for errors
      Unclassified, // a TC which was not classified yet
      Lost, // reference TCs which were not found by test TF
      RefOutlier, // reference TC which was rejected by some cuts or thresholds set by some classifier
      Ghost, // did not reach m_PARAMqiThreshold
      SmallStump, // TC too short
      Clone, // reached threshold but for the same reference TC a better partner was already found
      Contaminated, // more than m_PARAMqiThreshold in purity
      Clean, // test TC has 100% purity for the particle type but not all hits of reference TC were found
      Perfect, // test TC is identical with a reference TC (have exactly the same hits and no extra ones)
      AllTCTypes, // all other test types are smaller than this value
      Reference, // reference TC
      NTypes // number of tcTypes available
    };
 
 
    // WARNING TODO: and isValidString (and for AlgorithmType the same...)
    static bool isValidType(TCType::Type type)
    {
      return ((TCType::s_fromTypeToString.find(type) == TCType::s_fromTypeToString.end()) ? false : true);
    }
 
 
    static bool isValidName(std::string type)
    {
      return ((TCType::s_fromStringToType.find(type) == TCType::s_fromStringToType.end()) ? false : true);
    }
 
 
    static std::string getTypeName(TCType::Type type)
    {
      auto pos = TCType::s_fromTypeToString.find(type);
      if (pos == TCType::s_fromTypeToString.end()) {
        B2ERROR("TCType::getTypeName(): given iD " << type << " is not a valid TCType, returnint TCType::UnknownType!");
        return TCType::s_fromTypeToString[UnknownType];
      }
      return pos->second;
    }
 
 
    static TCType::Type getTypeEnum(std::string type)
    {
      auto pos = TCType::s_fromStringToType.find(type);
      if (pos == TCType::s_fromStringToType.end()) {
        B2ERROR("TCType::getTypeName(): given iD " << type << " is not a valid TCType, returnint TCType::UnknownType!");
        return TCType::s_fromStringToType[std::string("UnknownType")];
      }
      return pos->second;
    }
 
 
    static bool isReference(TCType::Type aType)
    {
      return aType == TCType::Reference
             or aType == TCType::Lost
             or aType == TCType::RefOutlier;
    }
 
 
    static bool isTestTC(TCType::Type aType)
    {
      return aType > TCType::RefOutlier
             and aType < TCType::AllTCTypes;
    }
 
 
    static bool isGoodTestTC(TCType::Type aType)
    {
      return aType > TCType::Clone
             and aType < TCType::AllTCTypes;
    }
 
 
  protected:
    static std::map<Type, std::string> s_fromTypeToString;
 
    static std::map<std::string, Type> s_fromStringToType;
  };
 
 
 
 
}