Utils.h

Go to the documentation of this file.

#ifndef NAIA_UTILS_H
#define NAIA_UTILS_H

#include <algorithm>
#include <array>
#include <limits>
#include <map>

#include "Utility/BitMask/bitmask.h"

// templated helper functions
#include "Containers/Utils.hpp"

// bitmask-able enums declaration
namespace NAIA {
enum class Category;
}
NAIA_ENABLE_BITMASK_OPERATORS(NAIA::Category)

namespace NAIA {

inline std::vector<std::string> TokenizeString(const std::string &input, const char separator) {
  std::vector<std::string> result;

  for (auto iter = cbegin(input);; /*nothing here*/) {
    auto sepIter = std::find(iter, end(input), separator);

    result.emplace_back(iter, sepIter);

    if (sepIter == cend(input))
      break;
    iter = std::next(sepIter);
  }

  return result;
}

template <class T> using LayerVariable = std::map<unsigned int, T>;

enum class Category {
  None = 0,
  HasTof = 1 << 0,            
  HasTrack = 1 << 1,          
  HasEcal = 1 << 2,           
  HasTrd = 1 << 3,            
  HasRich = 1 << 4,           
  HasTofStandalone = 1 << 5,  
  HasTrdStandalone = 1 << 6,  
  Charge1_Trk = 1 << 7,       
  Charge2_Trk = 1 << 8,       
  ChargeGT2_Trk = 1 << 9,     
  Charge1_Tof = 1 << 10,      
  Charge2_Tof = 1 << 11,      
  ChargeGT2_Tof = 1 << 12,    
  Charge1_Trk_St = 1 << 13,   
  Charge2_Trk_St = 1 << 14,   
  ChargeGT2_Trk_St = 1 << 15, 
  Charge1_Tof_St = 1 << 16,   
  Charge2_Tof_St = 1 << 17,   
  ChargeGT2_Tof_St = 1 << 18, 
};

namespace TrTrack {
// helper categories to handle charge reconstructions
constexpr unsigned int numChargeRecos = 3;
enum ChargeRecoType {
  STD, 
  HL,  
  YJ,  
};
constexpr std::array<ChargeRecoType, numChargeRecos> recoTypes{ChargeRecoType::STD, ChargeRecoType::HL,
                                                               ChargeRecoType::YJ};

// helper category for track z positions
constexpr unsigned int numFitPositionHeights = 16;
enum FitPositionHeight {
  Layer1 = 0,
  Layer2,
  Layer3,
  Layer4,
  Layer5,
  Layer6,
  Layer7,
  Layer8,
  Layer9,
  TofLayer0,
  TofLayer1,
  TofLayer2,
  TofLayer3,
  EcalCOG,
  EcalTop,
  EcalBottom,
};

constexpr std::array<FitPositionHeight, numFitPositionHeights> fitPositionHeights = {
    FitPositionHeight::Layer1,    FitPositionHeight::Layer2,    FitPositionHeight::Layer3,
    FitPositionHeight::Layer4,    FitPositionHeight::Layer5,    FitPositionHeight::Layer6,
    FitPositionHeight::Layer7,    FitPositionHeight::Layer8,    FitPositionHeight::Layer9,
    FitPositionHeight::TofLayer0, FitPositionHeight::TofLayer1, FitPositionHeight::TofLayer2,
    FitPositionHeight::TofLayer3, FitPositionHeight::EcalCOG,   FitPositionHeight::EcalTop,
    FitPositionHeight::EcalBottom};

constexpr std::array<float, numFitPositionHeights> fitPositionHeightZ = {
    159.04,  53.05,  29.22,  25.24,   1.706,   -2.292, -25.26,   -29.25,
    -136.03, 64.425, 61.325, -62.875, -64.425, 0,      -142.732, -159.382};

static const std::array<std::string, numFitPositionHeights> fitPositionNames{
    "Layer1", "Layer2",    "Layer3",    "Layer4",    "Layer5",    "Layer6",  "Layer7",  "Layer8",
    "Layer9", "TofLayer0", "TofLayer1", "TofLayer2", "TofLayer3", "EcalCOG", "EcalTop", "EcalBottom"};

constexpr unsigned int numTrLayers = 9;

constexpr std::array<FitPositionHeight, numTrLayers> layerPositionHeights = {
    FitPositionHeight::Layer1, FitPositionHeight::Layer2, FitPositionHeight::Layer3,
    FitPositionHeight::Layer4, FitPositionHeight::Layer5, FitPositionHeight::Layer6,
    FitPositionHeight::Layer7, FitPositionHeight::Layer8, FitPositionHeight::Layer9};

// helper categories to handle track spans
constexpr unsigned int numSpans = 7;
enum Span {
  NoSpan = -1,
  InnerOnly,      
  InnerL1,        
  InnerL9,        
  FullSpan,       
  UpperHalfInner, 
  LowerHalfInner, 
  InnerNoMS,      
};
constexpr std::array<Span, numSpans> spanTypes{Span::InnerOnly, Span::InnerL1,        Span::InnerL9,
                                               Span::FullSpan,  Span::UpperHalfInner, Span::LowerHalfInner,
                                               Span::InnerNoMS};
static const std::array<std::string, numSpans> spanNames{"InnerOnly",      "InnerL1",        "InnerL9",  "FullSpan",
                                                         "UpperHalfInner", "LowerHalfInner", "InnerNoMS"};

// helper categories to handle track fits
constexpr unsigned int numFits = 4;
enum Fit {
  NoFit = -1,
  Choutko,        
  Kalman,         
  GBL,            
  KalmanElectron, 
};
constexpr std::array<Fit, numFits> fitTypes{Fit::Choutko, Fit::Kalman, Fit::GBL, Fit::KalmanElectron};
static const std::array<std::string, numFits> fitNames{"Choutko", "Kalman", "GBL", "KalmanElectron"};

// helper categories to handle track geometries
constexpr unsigned int numTrGeos = 4;
enum class TrGeometry { Default = 0, InnerOnly, InnerL1, FullSpan };
constexpr std::array<TrGeometry, numTrGeos> trGeoTypes{TrGeometry::Default, TrGeometry::InnerOnly, TrGeometry::InnerL1,
                                                       TrGeometry::FullSpan};
static const std::array<std::string, numTrGeos> trGeoNames{"Default", "InnerOnly", "InnerL1", "FullSpan"};

// helper categories to handle track sides
constexpr unsigned int numSides = 2;
enum Side { X, Y };
constexpr std::array<Side, numSides> sides{Side::X, Side::Y};
static const std::array<std::string, numSides> sideNames{"X", "Y"};

// helper categories to handle track sides
constexpr unsigned int numTrackDistances = 7;
enum DistanceFromTrack { OnTrack, Onemm, Onecm, Twocm, Fivecm, Tencm, AllLayer };
constexpr std::array<DistanceFromTrack, numTrackDistances> trackDistances{
    DistanceFromTrack::OnTrack, DistanceFromTrack::Onemm, DistanceFromTrack::Onecm,   DistanceFromTrack::Twocm,
    DistanceFromTrack::Fivecm,  DistanceFromTrack::Tencm, DistanceFromTrack::AllLayer};
static const std::array<std::string, numTrackDistances> trackDistanceNames{"OnTrack", "Onemm", "Onecm",   "Twocm",
                                                                           "Fivecm",  "Tencm", "AllLayer"};

} // namespace TrTrack

namespace TrdK {

// helper categories to handle charge reconstructions
constexpr unsigned int numChargeTypes = 3;
enum ChargeType {
  Total, 
  Upper, 
  Lower, 
};
constexpr std::array<ChargeType, numChargeTypes> recoTypes{ChargeType::Total, ChargeType::Upper, ChargeType::Lower};
static const std::array<std::string, numChargeTypes> recoNames{"Total", "Upper", "Lower"};

// helper categories to handle likelihoods
constexpr unsigned int numLikelihoodTypes = 3;
enum LikelihoodType { Electron, Proton, Helium, Deuterium };
constexpr std::array<LikelihoodType, numLikelihoodTypes> likelihoodTypes{
    LikelihoodType::Electron, LikelihoodType::Proton, LikelihoodType::Helium};
static const std::array<std::string, numLikelihoodTypes> likelihoodNames{"Electron", "Proton", "Helium"};

// helper categories to handle likelihood ratios
constexpr unsigned int numLikelihoodRTypes = 3;
enum LikelihoodRType {
  ep,  
  eHe, 
  pHe, 
};
constexpr std::array<LikelihoodRType, numLikelihoodRTypes> likelihoodRTypes{LikelihoodRType::ep, LikelihoodRType::eHe,
                                                                            LikelihoodRType::pHe};
static const std::array<std::string, numLikelihoodRTypes> likelihoodRNames{"ep", "eHe", "pHe"};

// helper categories to handle ontrack/offtrack variables
constexpr unsigned int numQualTypes = 2;
enum QualType {
  OnTrack,  
  OffTrack, 
};
constexpr std::array<QualType, numQualTypes> qualTypes{QualType::OnTrack, QualType::OffTrack};
static const std::array<std::string, numQualTypes> qualNames{"OnTrack", "OffTrack"};

} // namespace TrdK

namespace Ecal {
// helper categories to handle energy reconstructions
constexpr unsigned int numEnergyRecos = 5;
// clang-format off
enum EnergyRecoType {
  EnergyD,           
  EnergyE,           
  EnergyCorrEneE_E,  
  EnergyCorrEne2017, 
  EcalKEle,          
};
// clang-format on

constexpr std::array<EnergyRecoType, numEnergyRecos> recoTypes{
    EnergyRecoType::EnergyD, EnergyRecoType::EnergyE, EnergyRecoType::EnergyCorrEneE_E,
    EnergyRecoType::EnergyCorrEne2017, EnergyRecoType::EcalKEle};
static const std::array<std::string, numEnergyRecos> recoNames{"EnergyD", "EnergyE", "EnergyCorrEneE_E",
                                                               "EnergyCorrEne2017", "EcalKEle"};

// helper categories to handle WeiWei's likelihoods
constexpr unsigned int numLikelihoodTypes = 2;
enum LikelihoodType { Integral, LayerCombined };
constexpr std::array<LikelihoodType, numLikelihoodTypes> likelihoodTypeNames{LikelihoodType::Integral,
                                                                             LikelihoodType::LayerCombined};

// helper categories to handle BDT types
constexpr unsigned int numBDTTypes = 4;
enum BDTType { v5std, v5ada, v7std, v7ada };
constexpr std::array<BDTType, numBDTTypes> BDTTypes{BDTType::v5std, BDTType::v5ada, BDTType::v7std, BDTType::v7ada};
static const std::array<std::string, numBDTTypes> BDTNames{"v5std", "v5ada", "v7std", "v7ada"};

} // namespace Ecal

namespace Tof {

const float tofRefZ = 160.;

// helper categories to handle charge reconstructions
constexpr unsigned int numChargeTypes = 3;
enum ChargeType {
  Total, 
  Upper, 
  Lower, 
};
constexpr std::array<ChargeType, numChargeTypes> recoTypes{ChargeType::Total, ChargeType::Upper, ChargeType::Lower};
static const std::array<std::string, numChargeTypes> recoNames{"Total", "Upper", "Lower"};

// helper categories to handle beta reconstructions
constexpr unsigned int numBetaTypes = 2;
enum BetaType {
  BetaH, 
  Evgeni,
};
constexpr std::array<BetaType, numBetaTypes> betaTypes{BetaType::BetaH, BetaType::Evgeni};
static const std::array<std::string, numBetaTypes> betaNames{"BetaH", "Evgeni"};

// helper categories to handle beta clusters
constexpr unsigned int numBetaClusterTypes = 2;
enum BetaClusterType { OnTime, OffTime };
constexpr std::array<BetaClusterType, numBetaClusterTypes> betaClusterTypes{BetaClusterType::OnTime,
                                                                            BetaClusterType::OffTime};
static const std::array<std::string, numBetaClusterTypes> betaClusterTypeNames{"OnTime", "OffTime"};

} // namespace Tof

namespace MCTruth {
constexpr unsigned int numMCHeights = 13;
enum MCHeight { GenerationPoint = 0, L1, UpperTof, L2, L3, L4, L5, L6, L7, L8, LowerTof, RichRadiator, L9, Ecal };
constexpr std::array<MCHeight, numMCHeights> MCHeights{MCHeight::GenerationPoint,
                                                       MCHeight::L1,
                                                       MCHeight::UpperTof,
                                                       MCHeight::L2,
                                                       MCHeight::L3,
                                                       MCHeight::L4,
                                                       MCHeight::L5,
                                                       MCHeight::L6,
                                                       MCHeight::L7,
                                                       MCHeight::L8,
                                                       MCHeight::LowerTof,
                                                       MCHeight::RichRadiator,
                                                       MCHeight::L9};

constexpr std::array<float, numMCHeights> MCHeightsZ{std::numeric_limits<float>::max(),
                                                     159.04,
                                                     64.425,
                                                     53.05,
                                                     29.22,
                                                     25.24,
                                                     1.706,
                                                     -2.292,
                                                     -25.26,
                                                     -29.25,
                                                     -62.875,
                                                     -71.87,
                                                     -135.03};

} // namespace MCTruth

namespace Rich {
// helper categories to handle beta reconstructions
enum RichMeasType { NONE = 0, NaF, Agl };

constexpr unsigned int numBetaTypes = 4;
enum BetaType {
  CIEMAT, //< Refit and corrected
  SIMPLE, //< Reconstructed velocity using only hits (no charge)
  REFIT,  //<Beta estimate taking into account the number of photoelectrons for each hit
  LIP     //< Beta with LIP standalone algo
};
constexpr std::array<BetaType, numBetaTypes> betaTypes{BetaType::CIEMAT, BetaType::SIMPLE, BetaType::REFIT,
                                                       BetaType::LIP};
static const std::array<std::string, numBetaTypes> betaNames{"CIEMAT", "SIMPLE", "REFIT", "LIP"};
} // namespace Rich

} // namespace NAIA

#endif