Tof.cpp

Go to the documentation of this file.

#include "fmt/format.h"

#include "Containers/Tof.h"

namespace NAIA {
const std::string TofBase::BranchName = "TofBaseData";
const std::string TofPlus::BranchName = "TofPlusData";
const std::string TofBaseStandalone::BranchName = "TofBaseDataSt";
const std::string TofPlusStandalone::BranchName = "TofPlusDataSt";

void TofBaseData::Clear() {
  Beta.clear();
  Charge.clear();

  m_pointAndDir.clear();
}

void TofPlusData::Clear() {
  Chi2Coo = Chi2Time = 0;

  NTrkClusters = NBetaClusters = NChargeClusters = 0;
  ChargeLikelihoodEst = ChargeLikelihoodProb = 0;

  BetaPattern.clear();
  LayerGoodPathl.clear();
  LayerCharge.clear();
  LayerEdep.clear();
  NClusters.clear();
  AverageEdep.clear();
  AverageDTime.clear();
}

TVector3 TofBaseData::InterpolateAtZ(float z) const {
  // not elegant, but who cares
  float dxdz = m_pointAndDir.at(1)[0] / m_pointAndDir.at(1)[2];
  float dydz = m_pointAndDir.at(1)[1] / m_pointAndDir.at(1)[2];

  TVector3 result{m_pointAndDir.at(0)};
  result[0] += dxdz * (z - result[2]);
  result[1] += dydz * (z - result[2]);
  result[2] = z;

  return result;
}

void TofBaseData::Dump() const {
  fmt::print("{:=^120} \n", " TofBaseData ");

  if (!Beta.empty()) {
    fmt::print("{:<32}", " ");
    for (auto bType : Tof::betaTypes) {
      fmt::print("{:>15} ", Tof::betaNames[bType]);
    }
    fmt::print("\n");
    fmt::print("  {:<30} = ", "Beta");
    for (auto bType : Tof::betaTypes) {
      fmt::print("{:> 15.4f} ", ContainsKeys(Beta, bType) ? Beta.at(bType) : 0);
    }
    fmt::print("\n");
  }

  if (!Charge.empty()) {
    fmt::print("{:<32}", " ");
    for (auto cType : Tof::recoTypes) {
      fmt::print("{:>15} ", Tof::recoNames[cType]);
    }
    fmt::print("\n");
    fmt::print("  {:<30} = ", "Charge");
    for (auto cType : Tof::recoTypes) {
      fmt::print("{:> 15.4f} ", ContainsKeys(Charge, cType) ? Charge.at(cType) : 0);
    }
    fmt::print("\n");
    fmt::print("  {:<30} = ", "ChargeNoPL");
    for (auto cType : Tof::recoTypes) {
      fmt::print("{:> 15.4f} ", ContainsKeys(ChargeNoPL, cType) ? ChargeNoPL.at(cType) : 0);
    }
    fmt::print("\n");
  }
}

void TofPlusData::Dump() const {
  fmt::print("{:=^120} \n", " TofPlusData ");

  fmt::print("{:^15} {:^15} {:^15} {:^15} {:^15} {:^30}\n", "Chi2Coo", "Chi2Time", "NTrkClusters", "NBetaClusters",
             "NChargeClusters", "ChargeLikelihoodEst (prob)");
  fmt::print("{:^15} {:^15} {:^15} {:^15} {:^15} {:^30}\n", Chi2Coo, Chi2Time, NTrkClusters, NBetaClusters,
             NChargeClusters, fmt::format("{} ({})", ChargeLikelihoodEst, ChargeLikelihoodProb));

  if (!BetaPattern.empty()) {
    fmt::print("{:<32}", "Beta type");
    for (auto bType : Tof::betaTypes) {
      fmt::print("{:>15} ", Tof::betaNames[bType]);
    }
    fmt::print("\n");
    fmt::print("  {:<30} = ", "BetaPattern");
    for (auto bType : Tof::betaTypes) {
      fmt::print("{:> 15} ", ContainsKeys(BetaPattern, bType) ? BetaPattern.at(bType) : 0);
    }
    fmt::print("\n");
  }

  if (!LayerGoodPathl.empty()) {
    fmt::print("{:-^120}\n", "");
    fmt::print("{:<32}   {:>15} {:>15} {:>15}\n", " ", "LayerGoodPathl", "LayerCharge", "LayerEdep");
    for (size_t iLayer = 0; iLayer < LayerGoodPathl.size(); iLayer++) {
      auto LayerChargeV = ContainsKeys(LayerCharge, iLayer) ? LayerCharge.at(iLayer) : 0;
      auto LayerEdepV = ContainsKeys(LayerEdep, iLayer) ? LayerEdep.at(iLayer) : 0;
      fmt::print("  - {:<28} = {:>15} {:> 15.4f} {:> 15.4f}\n", fmt::format("Layer {}", iLayer), LayerGoodPathl[iLayer],
                 LayerChargeV, LayerEdepV);
    }
  }

  if (!NClusters.empty()) {
    fmt::print("{:-^120}\n", "");
    fmt::print("{:<32}   {:>15} {:>15} {:>15}\n", " ", "NClusters", "AverageDTime", "AverageEdep");
    for (size_t iLayer = 0; iLayer < LayerGoodPathl.size(); iLayer++) {
      if (ContainsKeys(NClusters, iLayer, Tof::BetaClusterType::OnTime))
        fmt::print("  - {:<28} = {:>15} {:> 15.4f} {:> 15.4f}\n", fmt::format("Layer {} (On Time)", iLayer),
                   NClusters.at(iLayer).at(Tof::BetaClusterType::OnTime),
                   AverageDTime.at(iLayer).at(Tof::BetaClusterType::OnTime),
                   AverageEdep.at(iLayer).at(Tof::BetaClusterType::OnTime));
      if (ContainsKeys(NClusters, iLayer, Tof::BetaClusterType::OffTime))
        fmt::print("  - {:<28} = {:>15} {:> 15.4f} {:> 15.4f}\n", fmt::format("Layer {} (Off Time)", iLayer),
                   NClusters.at(iLayer).at(Tof::BetaClusterType::OffTime),
                   AverageDTime.at(iLayer).at(Tof::BetaClusterType::OffTime),
                   AverageEdep.at(iLayer).at(Tof::BetaClusterType::OffTime));
    }
  }

  fmt::print("{:-^120}\n", "");
}

} // namespace NAIA