FPGATrackSimLayerStudyTool.cxx File Reference

#include "FPGATrackSimBinning/FPGATrackSimLayerStudyTool.h"
#include "AthenaBaseComps/AthMsgStreamMacros.h"
#include "FPGATrackSimBinning/IFPGATrackSimBinDesc.h"
#include "FPGATrackSimBinning/FPGATrackSimBinUtil.h"
#include "FPGATrackSimBinning/FPGATrackSimBinnedHits.h"
#include "FPGATrackSimObjects/FPGATrackSimTrackPars.h"
#include "TH1D.h"
#include "TH2D.h"
#include "TTree.h"
#include <algorithm>
#include <bit>
#include <numbers>

Go to the source code of this file.

Functions
void FPGATrackSimLayerStudyTool::fillBinLevelOutput	ATLAS_NOT_THREAD_SAFE (const FPGATrackSimBinUtil::IdxSet &idx, const FPGATrackSimBinnedHits::BinEntry &data)
void FPGATrackSimLayerStudyTool::fillBinningSummary	ATLAS_NOT_THREAD_SAFE (const std::vector< std::shared_ptr< const FPGATrackSimHit > > &hits)
void FPGATrackSimLayerStudyTool::parseTruthInfo	ATLAS_NOT_THREAD_SAFE (std::vector< FPGATrackSimTruthTrack > const &truthtracks)

Function Documentation

ATLAS_NOT_THREAD_SAFE() [1/3]

void FPGATrackSimLayerStudyTool::fillBinLevelOutput ATLAS_NOT_THREAD_SAFE	(	const FPGATrackSimBinUtil::IdxSet &	idx,
		const FPGATrackSimBinnedHits::BinEntry &	data )

Definition at line 181 of file FPGATrackSimLayerStudyTool.cxx.

{
  setBinPlotsActive(idx);
 
  // fill all truth 
  m_ptDist[0]->Fill(std::abs(1/m_truthpars.qOverPt));
  m_etaDist[0]->Fill(1/m_truthpars.eta);
  m_phiDist[0]->Fill(1/m_truthpars.phi);
  m_d0Dist[0]->Fill(1/m_truthpars.d0);
  m_z0Dist[0]->Fill(1/m_truthpars.z0);
 
  if (m_binPlotsActive) {
    for (auto& hit : data.hits) {
      m_phiShift_road->Fill(hit.phiShift);
      m_etaShift_road->Fill(hit.etaShift);
      m_phiShift2D_road->Fill(hit.phiShift, hit.hitptr->getR());
      m_etaShift2D_road->Fill(hit.etaShift, hit.hitptr->getR());
    }
 
    // fill param monitoring
    for (int i = 0; i < 2; i++) {
      // i=0 all, i=1 no missed layers, i=2 is one missed layer
      if ((i == 0)|| (data.lyrCnt() >= m_binnedhits->getNLayers() - (i - 1))) {
          // all layer hit
          m_ptDist[i]->Fill(std::abs(1 / m_truthpars.qOverPt));
          m_etaDist[i]->Fill(1 / m_truthpars.eta);
          m_phiDist[i]->Fill(1 / m_truthpars.phi);
          m_d0Dist[i]->Fill(1 / m_truthpars.d0);
          m_z0Dist[i]->Fill(1 / m_truthpars.z0);
        }
    }
 
    // Module mapping and Layer definition studies
    // first sort hits by r+z radii
    std::vector<FPGATrackSimBinUtil::StoredHit> sorted_hits = data.hits;
    std::sort(sorted_hits.begin(), sorted_hits.end(),
              [](const auto &hit1, const auto &hit2) {
                return hit1.rzrad() < hit2.rzrad();
              });
 
    // Fill tree
    ClearTreeVectors();
    m_bin_tree_bin = std::vector<unsigned>(idx);
    ATH_MSG_DEBUG("Output: Bin Tree bin" << idx);
    for (auto &hit : sorted_hits) {
      m_bin_tree_r.push_back(hit.hitptr->getR());
      m_bin_tree_z.push_back(hit.hitptr->getZ());
      m_bin_tree_id.push_back(hit.hitptr->getIdentifier());
      m_bin_tree_hash.push_back(hit.hitptr->getIdentifierHash());
      m_bin_tree_layer.push_back(hit.hitptr->getLayerDisk());
      m_bin_tree_side.push_back(hit.hitptr->getSide());
      m_bin_tree_etamod.push_back(hit.hitptr->getEtaModule());
      m_bin_tree_phimod.push_back(hit.hitptr->getPhiModule());
      m_bin_tree_dettype.push_back((int)hit.hitptr->getDetType());
      m_bin_tree_detzone.push_back((int)hit.hitptr->getDetectorZone());
    }
    m_bin_tree->Fill();
    m_binsFilledCnt++;
  }
}

ATLAS_NOT_THREAD_SAFE() [2/3]

void FPGATrackSimLayerStudyTool::fillBinningSummary ATLAS_NOT_THREAD_SAFE

(

const std::vector< std::shared_ptr< const FPGATrackSimHit > > &

hits

)

Definition at line 243 of file FPGATrackSimLayerStudyTool.cxx.

{
  m_inputHits->Fill(hits.size());
 
  for (auto &step : m_binnedhits->getBinTool().steps()) {
    for (auto bin : m_binnedhits->binnedHits()[step->stepNum()])
      m_hitsPerStepBin[step->stepNum()]->Fill(bin.data().hitCnt);
  }
 
  for (auto bin :m_binnedhits->binnedHits()[m_binnedhits->getBinTool().lastStep()->stepNum()]) {
    for (unsigned lyr = 0; lyr < m_binnedhits->getNLayers(); lyr++) {
      unsigned cnt = bin.data().hitsInLyr(lyr);
      m_hitsPerLayer->Fill(lyr, cnt);
      m_hitsPerLayer2D->Fill(lyr, cnt);
    }
  }
  m_binsFilled->Fill(m_binsFilledCnt);
  m_binsFilledCnt=0;
  
}

ATLAS_NOT_THREAD_SAFE() [3/3]

void FPGATrackSimLayerStudyTool::parseTruthInfo ATLAS_NOT_THREAD_SAFE

(

std::vector< FPGATrackSimTruthTrack > const &

truthtracks

)

Definition at line 294 of file FPGATrackSimLayerStudyTool.cxx.

                                                                                                                           {
  ATH_MSG_DEBUG("In parseTruthInfo, truthtracks size = " << truthtracks.size());
  m_truthIsValid = false;
  m_bin_tree_event++;
 
  const IFPGATrackSimBinDesc* bindesc = m_binnedhits->getBinTool().binDesc();
 
  if (truthtracks.size() == 0) return;
 
  // Convert to binning parameters and find truth bin for each step
  m_truthpars = (truthtracks)[0].getPars();
  m_truthpars[FPGATrackSimTrackPars::IHIP] =
      m_truthpars[FPGATrackSimTrackPars::IHIP] * 1000;
  m_truthparset = bindesc->trackParsToParSet(m_truthpars);
  m_truthbin.clear();
  for (auto &step : m_binnedhits->getBinTool().steps()) {
    m_truthbin.push_back(step->binIdx(m_truthparset));
  }
 
  // histogram parameters
  for (unsigned i = 0; i < FPGATrackSimTrackPars::NPARS; i++) {
    m_truthpars_hists[i]->Fill(m_truthparset[i]);
  }
 
  // a closure test
  FPGATrackSimTrackPars recovered = bindesc->parSetToTrackPars(m_truthparset);
  ATH_MSG_DEBUG("parset:" << m_truthparset << " " << m_truthpars
                          << " ?= " << recovered << " closure:"
                          << " " << recovered[FPGATrackSimTrackPars::IHIP] - m_truthpars[FPGATrackSimTrackPars::IHIP]
                          << " " << recovered[FPGATrackSimTrackPars::IPHI] - m_truthpars[FPGATrackSimTrackPars::IPHI]
                          << " " << recovered[FPGATrackSimTrackPars::ID0] - m_truthpars[FPGATrackSimTrackPars::ID0]
                          << " " << recovered[FPGATrackSimTrackPars::IETA] - m_truthpars[FPGATrackSimTrackPars::IETA]
                          << " " << recovered[FPGATrackSimTrackPars::IZ0] - m_truthpars[FPGATrackSimTrackPars::IZ0]);
 
  m_truth_tree_phi = m_truthpars[FPGATrackSimTrackPars::IPHI];
  m_truth_tree_qOverPt = m_truthpars[FPGATrackSimTrackPars::IHIP];
  m_truth_tree_d0 = m_truthpars[FPGATrackSimTrackPars::ID0];
  m_truth_tree_z0 = m_truthpars[FPGATrackSimTrackPars::IZ0];
  m_truth_tree_eta = m_truthpars[FPGATrackSimTrackPars::IETA];
  m_truth_tree_parset = std::vector<double>(m_truthparset);
  m_truth_tree->Fill();
 
  // print if there are multiple tracks for debugging single track MC
  if (truthtracks.size() > 1) {
    for (unsigned i = 0; i < truthtracks.size(); i++) {
      ATH_MSG_INFO("Multiple truth" << i << " of " << truthtracks.size()
                                    << " " << (truthtracks)[i].getPars());
    }
  }
 
  // find truth bin for later plotting selections
  ATH_MSG_DEBUG("truthbin " << truthtracks.size()
                            << " " << m_truthpars << " " << m_truthbin);
 
  // Check if the truth track falls in the binning range
  if (!m_binnedhits->getBinTool().inRange(m_truthparset)) {
    ATH_MSG_INFO("Truth out of range because truth parset = " << m_truthparset << " wrt min = " << m_binnedhits->getBinTool().parMin() << ", max = " << m_binnedhits->getBinTool().parMax());
    return;
  }
 
  // Check that truth track falls in an actual bin
  // this should alway pass, except for weird events
  m_truthIsValid = true;
  for (auto &step : m_binnedhits->getBinTool().steps()) {
    if (!step->validBinsFull()[m_truthbin[step->stepNum()]]) {
      ATH_MSG_INFO("Truth Bin not valid! Step " << step->stepName() << " "
                                                << m_truthbin[step->stepNum()]
                                                << " : " << m_truthpars);
      std::vector<FPGATrackSimBinUtil::IdxSet> idxsets =
          FPGATrackSimBinUtil::makeVariationSet(
              std::vector<unsigned>({0, 1, 2, 3, 4}),
              m_truthbin[step->stepNum()]);
      for (FPGATrackSimBinUtil::IdxSet &idxset : idxsets) {
        ATH_MSG_INFO("Truth Box "
                     << bindesc->parSetToTrackPars(step->binLowEdge(idxset)));
      }
      m_truthIsValid = false;
    }
  }
}