TrTrack.cpp

Go to the documentation of this file.

#include <bitset>
#include <fmt/format.h>

#include "Containers/TrTrack.h"

namespace NAIA {
const std::string TrTrackBase::BranchName = "TrTrackBaseData";
const std::string TrTrackPlus::BranchName = "TrTrackPlusData";
const std::string SecondTrTrackBase::BranchName = "SecondTrTrackBaseData";
const std::string TrTrackBaseStandalone::BranchName = "TrTrackBaseDataSt";

using namespace TrTrack;

bool TrTrackBaseData::FitIDExists(Fit fit, Span span) const {
  return (Rigidity.find(fit) != end(Rigidity) && Rigidity.at(fit).find(span) != end(Rigidity.at(fit)));
}

Span TrTrackBaseData::GetBestSpan(Fit fit) const {
  Span bestspan = FitIDExists(fit, Span::FullSpan)
                      ? Span::FullSpan
                      : (FitIDExists(fit, Span::InnerL1) > 0
                             ? Span::InnerL1
                             : (FitIDExists(fit, Span::InnerL9) > 0 ? Span::InnerL9 : Span::InnerOnly));
  return bestspan;
}

void TrTrackBaseData::Clear() {
  TrTrackHitPos.clear();
  TrTrackFitPos.clear();

  Rigidity.clear();
  TrChiSq.clear();

  Charge.clear();
  ChargeRMS.clear();
  InnerCharge.clear();
  InnerChargeRMS.clear();
  LayerChargeXY.clear();
  LayerChargeStatus.clear();

  _beta = 1.0f;
  _fit_ID.clear();
}

void TrTrackPlusData::Clear() {
  TrackFeetDistance.clear();

  RigidityTOI.clear();
  InvRigErr.clear();
  PartialRigidity.clear();
  PartialInvRigErr.clear();
  PartialTrChiSq.clear();
  PartialTrTrackResidual.clear();

  TrTrackResidual.clear();
  UnbiasedCharge.clear();
  LayerCharge.clear();
  LayerEdep.clear();

  NClusters.clear();
  ClustersEdep.clear();
  MaxClusterEdep.clear();
  MaxClusterDistance.clear();
  ClusterSignalRatio.clear();

  DirectionalStoermerCutoff = {0, 0};

  _fit_ID.clear();
}

void TrTrackBaseData::Dump() const {
  fmt::print("{:=^120} \n", " TrTrackBaseData ");
  if (!Rigidity.empty()) {
    for (const auto &fitIter : Rigidity) {
      fmt::print("Fit {}\n", TrTrack::fitNames[fitIter.first]);
      fmt::print("  {:<30}   {:>15} {:>15} {:>15}\n", "Span", "Rigidity", "TrChiSqX", "TrChiSqY");
      for (auto spanIter : fitIter.second) {
        fmt::print("  - {:<28} = {:> 12.4f} GV {:> 15.4f} {:> 15.4f}\n", TrTrack::spanNames[spanIter.first],
                   spanIter.second, TrChiSq.at(fitIter.first).at(spanIter.first).at(Side::X),
                   TrChiSq.at(fitIter.first).at(spanIter.first).at(Side::Y));
      }
    }
  }

  if (!Charge.empty()) {
    fmt::print("{:-^120}\n", "");
    fmt::print("{:<32}   {:>15} {:>15} {:>15} {:>32}\n", "Charge type", "Standard", "Hu Liu", "Yi Jia", "status");

    fmt::print("  - {:<28} = ", "Global charge");
    for (auto chType : TrTrack::recoTypes) {
      fmt::print("{:> 15.4f} ", ContainsKeys(Charge, chType) ? Charge.at(chType) : 0);
    }
    fmt::print("\n");

    fmt::print("  - {:<28} = ", "Inner tracker charge");
    for (auto chType : TrTrack::recoTypes) {
      fmt::print("{:> 15.4f} ", ContainsKeys(InnerCharge, chType) ? InnerCharge.at(chType) : 0);
    }
    fmt::print("\n");

    fmt::print("  - {:<28} = ", "Global charge RMS");
    for (auto chType : TrTrack::recoTypes) {
      fmt::print("{:> 15.4f} ", ContainsKeys(ChargeRMS, chType) ? ChargeRMS.at(chType) : 0);
    }
    fmt::print("\n");

    fmt::print("  - {:<28} = ", "Inner tracker charge RMS");
    for (auto chType : TrTrack::recoTypes) {
      fmt::print("{:> 15.4f} ", ContainsKeys(InnerChargeRMS, chType) ? InnerChargeRMS.at(chType) : 0);
    }
    fmt::print("\n");

    for (size_t ijl = 0; ijl < 9; ijl++) {
      if (!ContainsKeys(LayerChargeXY, ijl))
        continue;

      fmt::print("  - {:<28} = ", fmt::format("Layer {}", ijl));
      for (auto chType : TrTrack::recoTypes) {
        if (ContainsKeys(LayerChargeXY, ijl, chType))
          fmt::print("{:> 15.4f} ", LayerChargeXY.at(ijl).at(chType));
        else
          fmt::print("{:>15} ", "");
      }
      std::bitset<32> dummy(ContainsKeys(LayerChargeStatus, ijl) ? LayerChargeStatus.at(ijl) : 0xFFFF);
      fmt::print("{:>32} ", dummy.to_string());
      fmt::print("\n");
    }
  }

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

void TrTrackPlusData::Dump() const {
  fmt::print("{:=^120} \n", " TrTrackPlusData ");
  if (!InvRigErr.empty()) {
    for (const auto &fitIter : InvRigErr) {
      fmt::print("Fit {}\n", TrTrack::fitNames[fitIter.first]);
      if (RigidityTOI.find(fitIter.first) == end(RigidityTOI)) {
        fmt::print("  {:<30}   {:>15} {:>15}\n", "Span", "", "InvRigErr");
        for (auto spanIter : fitIter.second) {
          fmt::print("  - {:<28} = {:>15} {:>15}\n", TrTrack::spanNames[spanIter.first], "",
                     InvRigErr.at(fitIter.first).at(spanIter.first));
        }
      } else {
        fmt::print("  {:<30}   {:>15} {:>15}\n", "Span", "RigidityTOI", "InvRigErr");
        for (auto spanIter : fitIter.second) {
          fmt::print("  - {:<28} = {:> 12.4f} GV {:>15}\n", TrTrack::spanNames[spanIter.first],
                     RigidityTOI.at(fitIter.first).at(spanIter.first), InvRigErr.at(fitIter.first).at(spanIter.first));
        }
      }
    }
  }

  fmt::print("{:-^120}\n", "");
  fmt::print("{:<32}   {:>15} {:>15} {:>15} {:>15}\n", "\"Partial\" variables", "Rigidity", "InvRigErr", "TrChiSqX",
             "TrChiSqY");
  for (unsigned int ijl = 0; ijl < 9; ijl++) {
    if (!ContainsKeys(PartialRigidity, ijl))
      continue;

    for (auto &fitIter : PartialRigidity.at(ijl)) {
      auto fit = fitIter.first;

      fmt::print("  - {:<28} = {:>15} {:>15} {:>15} {:>15}\n",
                 fmt::format("Layer {} - Fit {}", ijl + 1, TrTrack::fitNames[fit]), PartialRigidity.at(ijl).at(fit),
                 PartialInvRigErr.at(ijl).at(fit), PartialTrChiSq.at(ijl).at(fit).at(TrTrack::Side::X),
                 PartialTrChiSq.at(ijl).at(fit).at(TrTrack::Side::Y));
    }
  }

  if (!LayerCharge.empty()) {
    fmt::print("{:-^120}\n", "");
    fmt::print("{:<32}   {:>15} {:>15} {:>15}\n", "Charge type", "Standard", "Hu Liu", "Yi Jia");
    for (size_t ijl = 0; ijl < 9; ijl++) {
      fmt::print("  - {:<28} = ", fmt::format("Layer {} X", ijl));
      for (auto chType : TrTrack::recoTypes) {
        if (ContainsKeys(LayerCharge, ijl, chType, TrTrack::Side::X))
          fmt::print("{:> 15.4f} ", LayerCharge.at(ijl).at(chType).at(TrTrack::Side::X));
        else
          fmt::print("{:>15} ", "");
      }
      fmt::print("\n");
      fmt::print("  - {:<28} = ", fmt::format("Layer {} Y", ijl));
      for (auto chType : TrTrack::recoTypes) {
        if (ContainsKeys(LayerCharge, ijl, chType, TrTrack::Side::Y))
          fmt::print("{:> 15.4f} ", LayerCharge.at(ijl).at(chType).at(TrTrack::Side::Y));
        else
          fmt::print("{:>15} ", "");
      }
      fmt::print("\n");
    }
  }
  fmt::print("{:-^120}\n", "");
}

std::bitset<9> TrTrackBaseData::GetTrackPattern(TrTrack::Side side) {
  auto result = std::bitset<9>{0};

  for (unsigned int i = 0u; i < 9; ++i) {
    if (ContainsKeys(TrTrackHitPos, i, side)) {
      result[i] = true;
    }
  }

  return result;
}
} // namespace NAIA