eventAnalysisEnums.hxx

Go to the documentation of this file.

#ifndef OANALYSISDEFS_HXX
#define OANALYSISDEFS_HXX

#include <iostream>
#include <stdexcept>
#include <string>

#include "TEnv.h"
#include "TMath.h"
#include "TObject.h"
#include "TParticlePDG.h"
#include "TSystem.h"

/// Utility tools to be shared across analysis classes
///
/// Mostly bookkeeping routines to ensure consistency and
/// easy referencing
namespace eventAnalysisEnums {

enum ESubdetector {
  kFGD1          = 0,
  kFGD2          = 1,
  kTPC1          = 2,
  kTPC2          = 3,
  kTPC3          = 4,
  kSFG           = 5,
  kTopHAT        = 6,
  kBottomHAT     = 7,
  kTOF           = 8,
  kP0D           = 9,  // include UsECal
  kDsECal        = 10,
  kBrlECalTop    = 11,
  kBrlECalBottom = 12,
  kBrlECalLeft   = 13,
  kBrlECalRight  = 14,
  kP0DECalTop    = 15,
  kP0DECalBottom = 16,
  kP0DECalLeft   = 17,
  kP0DECalRight  = 18,
  kSMRD          = 19,
  kOffAxis       = 20, /// the rest of the off-axis detector
  kINGRID        = 21,
  kCavern        = 22,
  kNSubdetectors = 23
};



enum EParticleCategory {
  kChargedLepton = 0,
  kChargedBaryon,
  kChargedMeson,
  kPhoton,
  kOtherCharged,
  kOtherNeutral,
  kOther,
  kNParticleCategories
};


const unsigned long DetMask[] = {
  1UL<<kFGD1,
  1UL<<kFGD2,
  1UL<<kTPC1,
  1UL<<kTPC2,
  1UL<<kTPC3,
  1UL<<kSFG,
  1UL<<kTopHAT,
  1UL<<kBottomHAT,
  1UL<<kTOF,
  1UL<<kP0D,
  1UL<<kDsECal,
  1UL<<kBrlECalTop,
  1UL<<kBrlECalBottom, 
  1UL<<kBrlECalLeft, 
  1UL<<kBrlECalRight, 
  1UL<<kP0DECalTop,
  1UL<<kP0DECalBottom,
  1UL<<kP0DECalLeft,
  1UL<<kP0DECalRight,
  1UL<<kSMRD,
  1UL<<kOffAxis,
  1UL<<kINGRID,
  1UL<<kCavern,
  1UL<<kNSubdetectors
};

inline void SetDetectorUsed(unsigned long &BitField, ESubdetector det){
  BitField = BitField | 1UL<<det;
}

inline bool GetDetectorUsed(unsigned long BitField, ESubdetector det){
  return BitField & DetMask[det];
}



inline ESubdetector PathToSubdetector(const std::string path) {
  
  // Below t2k/OA/Magnet, 
  //  - Basket
  //  - LeftClam
  //  - RightClam
  // exist.

  // Basket includes 
  // - P0D (including USECal)
  // - DsECal
  // - Tracker (including TPC1, TPC2, TPC3, FGD1, FGD2)
  // - SFG
  // - TopHAT, BottomHAT
  // - DTOF, UTOF, BTOF, TTOF, STOF
  
  if (path.find("Basket") != std::string::npos) {
    // P0D
    if (path.find("P0D") != std::string::npos) {
      return kP0D;
    }
    // DsECal
    else if (path.find("DsECal") != std::string::npos) {
      return kDsECal;
    }
    // FGD1
    else if (path.find("FGD1") != std::string::npos) {
      return kFGD1;
    }
    // FGD2
    else if (path.find("FGD2") != std::string::npos) {
      return kFGD2;
    }
    // TPC1
    else if (path.find("TPC1") != std::string::npos) {
      return kTPC1;
    }
    // TPC2
    else if (path.find("TPC2") != std::string::npos) {
      return kTPC2;
    }
    // TPC3
    else if (path.find("TPC3") != std::string::npos) {
      return kTPC3;
    }
    // SFGD
    else if (path.find("SFG") != std::string::npos) {
      return kSFG;
    }
    // HAT
    else if (path.find("TopHAT") != std::string::npos) {
      return kTopHAT;
    }
    else if (path.find("BottomHAT") != std::string::npos) {
      return kBottomHAT;
    }
    // TOF 
    else if (path.find("TOF") != std::string::npos) {
      return kTOF;
    }
  }

  // LeftClam/RightClam includes 
  // - BrlECal
  // - P0DECal
  // - MRD

  if (path.find("Clam") != std::string::npos) {
    // BrlECal
    if (path.find("BrlECal") != std::string::npos) {
      if (path.find("Top") != std::string::npos) {
        return kBrlECalTop;
      } else if (path.find("Side") != std::string::npos) {
        if (path.find("LeftClam") != std::string::npos) {
          return kBrlECalLeft;
        } else if (path.find("RightClam") != std::string::npos) {
          return kBrlECalRight;
        }
      } else if (path.find("Bottom") != std::string::npos) {
        return kBrlECalBottom;
      }
    }
    // P0DECal
    else if (path.find("P0DECal") != std::string::npos) {
      if (path.find("Top") != std::string::npos) {
        return kP0DECalTop;
      } else if (path.find("Side") != std::string::npos) {
        if (path.find("LeftClam") != std::string::npos) {
          return kP0DECalLeft;
        } else if (path.find("RightClam") != std::string::npos) {
          return kP0DECalRight;
        }
      } else if (path.find("Bottom") != std::string::npos) {
        return kP0DECalBottom;
      }
    }
    // SMRD
    else if ((path.find("MRD") != std::string::npos) ||
             (path.find("FluxReturn") != std::string::npos)) {
      return kSMRD;
    }
  }

  // Other parts of the off-axis
  if (path.find("OA") != std::string::npos) {
    return kOffAxis;
  }
  // INGRID
  else if (path.find("INGRID") != std::string::npos) {
    return kINGRID;
  } else {
    return kCavern;
  }
}

inline std::string DetectorName(ESubdetector const subdet) {
  switch (subdet) {
  case kFGD1: {
    return "FGD1";
  }
  case kFGD2: {
    return "FGD2";
  }
  case kTPC1: {
    return "TPC1";
  }
  case kTPC2: {
    return "TPC2";
  }
  case kTPC3: {
    return "TPC3";
  }
  case kSFG: {
    return "SFG";
  }
  case kTopHAT: {
    return "THAT";
  }
  case kBottomHAT: {
    return "BHAT";
  }
  case kTOF: {
    return "TOF";
  }
  case kP0D: {
    return "P0D";
  }
  case kDsECal: {
    return "DsECal";
  }
  case kBrlECalTop: {
    return "BrlECalTop";
  }
  case kBrlECalBottom: {
    return "BrlECalBottom";
  }
  case kBrlECalLeft: {
    return "BrlECalLeft";
  }
  case kBrlECalRight: {
    return "BrlECalRight";
  }
  case kP0DECalTop: {
    return "P0DECalTop";
  }
  case kP0DECalBottom: {
    return "P0DECalBottom";
  }
  case kP0DECalLeft: {
    return "P0DECalLeft";
  }
  case kP0DECalRight: {
    return "P0DECalRight";
  }
  case kSMRD: {
    return "SMRD";
  }
  case kOffAxis: {
    return "OffAxis";
  }
  case kINGRID: {
    return "INGRID";
  }
  case kCavern: {
    return "Cavern";
  }
  default: { return "NONE"; }
  }
}

inline ESubdetector Next(ESubdetector const subdet) {
  switch (subdet) {
  case kFGD1: {
    return kFGD2;
  }
  case kFGD2: {
    return kTPC1;
  }
  case kTPC1: {
    return kTPC2;
  }
  case kTPC2: {
    return kTPC3;
  }
  case kTPC3: {
    return kSFG;
  }
  case kSFG: {
    return kTopHAT;
  }
  case kTopHAT: {
    return kBottomHAT;
  }
  case kBottomHAT: {
    return kTOF;
  }
  case kTOF: {
    return kP0D;
  }
  case kP0D: {
    return kDsECal;
  }
  case kDsECal: {
    return kBrlECalTop;
  }
  case kBrlECalTop: {
    return kBrlECalBottom;
  }
  case kBrlECalBottom: {
    return kBrlECalLeft;
  }
  case kBrlECalLeft: {
    return kBrlECalRight;
  }
  case kBrlECalRight: {
    return kP0DECalTop;
  }
  case kP0DECalTop: {
    return kP0DECalBottom;
  }
  case kP0DECalBottom: {
    return kP0DECalLeft;
  }
  case kP0DECalLeft: {
    return kP0DECalRight;
  }
  case kP0DECalRight: {
    return kSMRD;
  }
  case kSMRD: {
    return kOffAxis;
  }
  case kOffAxis: {
    return kINGRID;
  }
  case kINGRID: {
    return kCavern;
  }
  case kCavern: {
    return kNSubdetectors;
  }
  default: { return kNSubdetectors; }
  }
}

inline ESubdetector IntToSubdetector(int const intdet) {
  ESubdetector subdet = static_cast<ESubdetector>(intdet);
  switch (subdet) {
  case kFGD1: {
    return kFGD1;
  }
  case kFGD2: {
    return kFGD2;
  }
  case kTPC1: {
    return kTPC1;
  }
  case kTPC2: {
    return kTPC2;
  }
  case kTPC3: {
    return kTPC3;
  }
  case kSFG: {
    return kSFG;
  }
  case kTopHAT: {
    return kTopHAT;
  }
  case kBottomHAT: {
    return kBottomHAT;
  }
  case kTOF: {
    return kTOF;
  }
  case kP0D: {
    return kP0D;
  }
  case kDsECal: {
    return kDsECal;
  }
  case kBrlECalTop: {
    return kBrlECalTop;
  }
  case kBrlECalBottom: {
    return kBrlECalBottom;
  }
  case kBrlECalLeft: {
    return kBrlECalLeft;
  }
  case kBrlECalRight: {
    return kBrlECalRight;
  }
  case kP0DECalTop: {
    return kP0DECalTop;
  }
  case kP0DECalBottom: {
    return kP0DECalBottom;
  }
  case kP0DECalLeft: {
    return kP0DECalLeft;
  }
  case kP0DECalRight: {
    return kP0DECalRight;
  }
  case kSMRD: {
    return kSMRD;
  }
  case kOffAxis: {
    return kOffAxis;
  }
  case kINGRID: {
    return kINGRID;
  }
  case kCavern: {
    return kCavern;
  }
  case kNSubdetectors: {
    return kNSubdetectors;
  }
  default: {
    std::cerr << "[ERROR](" << __FILE__ ":" << __LINE__
              << "): Attempted to cast " << intdet
              << " to a eventAnalysisEnums::ESubdetector." << std::endl;
    throw std::make_pair("eventAnalysisEnums::ESubdetector.", intdet);
  }
  }
}

inline EParticleCategory PDGInfoToCategory(const TParticlePDG *pdgInfo) {

  if (pdgInfo) {
    Int_t pdg = pdgInfo->PdgCode();
    // rounding Double_t charge/3 to closest Int_t (ROOT returns a double in
    // units of e/3!)
    Int_t charge = TMath::Nint(pdgInfo->Charge() / 3.0);
    std::string particleClass = pdgInfo->ParticleClass();
    // Charged Particles
    if (charge != 0) {
      // Leptons
      if ((TMath::Abs(pdg) == 11) || (TMath::Abs(pdg) == 13) ||
          (TMath::Abs(pdg) == 15)) {
        return kChargedLepton;
      }

      if (particleClass.find("Baryon") != std::string::npos) {
        return kChargedBaryon;
      } else if (particleClass.find("Meson") != std::string::npos) {
        return kChargedMeson;
      } else {
        return kOtherCharged;
      }
    } else if (pdg == 22) {
      return kPhoton;
    } else {
      return kOtherNeutral;
    }
  } else {
    return kOther;
  }
}
// 
//inline EParticleCategory PDGToCategory(const Int_t pdg) {
//  TParticlePDG pdgInfo(pdg); this constructor no longer exists in root 6
// and any way - it never did anything so this code is useless!
//  return PDGInfoToCategory(&pdgInfo);
//}

inline void UseCustomPDGTable() {
  TString tablePath = TString(gSystem->Getenv("EVENTANALYSISROOT")) +
                      "/input/oaanalysis_pdg_table.txt";
  bool Gottit = gSystem->AccessPathName(tablePath);
  if (Gottit) {
    std::cerr << "[ERROR](" << __FILE__ << ":" << __LINE__ << ") " << tablePath
              << " is not accesible, cannot load extra PDG data. "
                 "(Expect: "
                 "${EVENTANALYSISROOT}/input/oaanalysis_pdg_table.txt)"
              << std::endl;
    throw std::exception();
  }
  gEnv->SetValue("Root.DatabasePDG", tablePath);
}

inline std::string ParticleName(EParticleCategory const category) {
  switch (category) {
  case kChargedLepton: {
    return "Charged Lepton";
  }
  case kChargedBaryon: {
    return "Charged Baryon";
  }
  case kChargedMeson: {
    return "Charged Meson";
  }
  case kPhoton: {
    return "Photon";
  }
  case kOtherCharged: {
    return "Charged Other";
  }
  case kOtherNeutral: {
    return "Neutral Other";
  }
  case kOther: {
    return "Other";
  }
  default: { return "NONE"; }
  }
}

inline EParticleCategory Next(EParticleCategory const category) {
  switch (category) {
  case kChargedLepton: {
    return kChargedBaryon;
  }
  case kChargedBaryon: {
    return kChargedMeson;
  }
  case kChargedMeson: {
    return kPhoton;
  }
  case kPhoton: {
    return kOtherCharged;
  }
  case kOtherCharged: {
    return kOtherNeutral;
  }
  case kOtherNeutral: {
    return kOther;
  }
  case kOther: {
    return kNParticleCategories;
  }
  default: { return kNParticleCategories; }
  }
}
}

#endif // OANALYSISDEFS_HXX