AlgoritmType.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 AlgoritmType {
  public:
 
    enum Type {
      UnknownType, // defines unknown types
      AnalyzingAlgorithmBase,
      AnalyzingAlgorithmValuePX,
      AnalyzingAlgorithmValuePY,
      AnalyzingAlgorithmValuePZ,
      AnalyzingAlgorithmValuePT,
      AnalyzingAlgorithmValueP,
      AnalyzingAlgorithmValuePTheta,
      AnalyzingAlgorithmValuePPhi,
      AnalyzingAlgorithmValueDistSeed2IP,
      AnalyzingAlgorithmValueDistSeed2IPZ,
      AnalyzingAlgorithmValueDistSeed2IPXY,
      AnalyzingAlgorithmValueQI,
      AnalyzingAlgorithmResidualPX,
      AnalyzingAlgorithmResidualPY,
      AnalyzingAlgorithmResidualPZ,
      AnalyzingAlgorithmResidualPT,
      AnalyzingAlgorithmResidualP,
      AnalyzingAlgorithmResidualPTheta,
      AnalyzingAlgorithmResidualPPhi,
      AnalyzingAlgorithmResidualPAngle,
      AnalyzingAlgorithmResidualPTAngle,
      AnalyzingAlgorithmResidualPosition,
      AnalyzingAlgorithmResidualPositionXY,
      AnalyzingAlgorithmLostUClusters,
      AnalyzingAlgorithmLostVClusters,
      AnalyzingAlgorithmTotalUClusters,
      AnalyzingAlgorithmTotalVClusters,
      AnalyzingAlgorithmLostUEDep,
      AnalyzingAlgorithmLostVEDep,
      AnalyzingAlgorithmTotalUEDep,
      AnalyzingAlgorithmTotalVEDep,
      NTypes // number of analyzingAlgorithmTypes available
    };
 
 
    static bool isValidType(AlgoritmType::Type type)
    {
      return ((AlgoritmType::s_fromTypeToString.find(type) == AlgoritmType::s_fromTypeToString.end()) ? false : true);
    }
 
 
    static bool isValidName(std::string type)
    {
      return ((AlgoritmType::s_fromStringToType.find(type) == AlgoritmType::s_fromStringToType.end()) ? false : true);
    }
 
 
    static std::string getTypeName(AlgoritmType::Type type)
    {
      auto pos = AlgoritmType::s_fromTypeToString.find(type);
      if (pos == AlgoritmType::s_fromTypeToString.end()) {
        B2ERROR("AlgoritmType::getTypeName(): given iD " << type << " is not a valid AlgoritmType, return AlgoritmType::UnknownType!");
        return AlgoritmType::s_fromTypeToString[UnknownType];
      }
      return pos->second;
    }
 
 
    static AlgoritmType::Type getTypeEnum(std::string type)
    {
      auto pos = AlgoritmType::s_fromStringToType.find(type);
      if (pos == AlgoritmType::s_fromStringToType.end()) {
        B2ERROR("AlgoritmType::getTypeName(): given iD " << type << " is not a valid AlgoritmType, return AlgoritmType::UnknownType!");
        return AlgoritmType::s_fromStringToType[std::string("UnknownType")];
      }
      return pos->second;
    }
 
 
    static bool isValueDoubleType(AlgoritmType::Type aType)
    { return aType < AlgoritmType::AnalyzingAlgorithmResidualPX and aType > AlgoritmType::AnalyzingAlgorithmBase; }
 
    static bool isResidualDoubleType(AlgoritmType::Type aType)
    { return aType < AlgoritmType::AnalyzingAlgorithmLostUClusters and aType > AlgoritmType::AnalyzingAlgorithmValueQI; }
 
    static bool isHitValueIntType(AlgoritmType::Type aType)
    { return aType > AlgoritmType::AnalyzingAlgorithmResidualPositionXY and aType < AlgoritmType::AnalyzingAlgorithmLostUEDep; }
 
    static bool isHitValueVecDoubleType(AlgoritmType::Type aType)
    { return aType > AlgoritmType::AnalyzingAlgorithmTotalVClusters and aType < AlgoritmType::NTypes; }
 
  protected:
    static std::map<Type, std::string> s_fromTypeToString;
 
    static std::map<std::string, Type> s_fromStringToType;
  };
 
 
 
 
}