ClusterTruthTool.cxx

Go to the documentation of this file.

 
#include "ClusterTruthTool.h"
 
#include "GeneratorObjects/McEventCollection.h"
#include "HGTD_PrepRawData/HGTD_Cluster.h"
#include "InDetSimData/InDetSimDataCollection.h"
#include "xAODTruth/TruthParticle.h"
#include "TruthUtils/MagicNumbers.h"
#include "TLorentzVector.h"
 
HGTD::ClusterTruthTool::ClusterTruthTool(const std::string& t,
                                         const std::string& n,
                                         const IInterface* p)
    : base_class(t, n, p) {}
 
HGTD::ClusterTruthInfo HGTD::ClusterTruthTool::classifyCluster(
    const HGTD_Cluster* cluster, const xAOD::TruthParticle* tp,
    const InDetSimDataCollection* sim_data,
    const HepMC::GenEvent* hard_scatter_evnt) const {
 
  if (not sim_data or not tp) {
    return {HGTD::ClusterTruthOrigin::UNIDENTIFIED, false, false};
  }
 
  ATH_MSG_DEBUG("[ClusterTruthTool] " << sim_data->size() << " SDO elements");
  ATH_MSG_DEBUG("[ClusterTruthTool] all SimData IDs: ");
  for (const auto& elem : *sim_data) {
    ATH_MSG_DEBUG(elem.first);
  }
 
  const std::vector<Identifier>& rdo_id_list = cluster->rdoList();
  // keep record of the cluster origins and if they are shadowed or not
  std::vector<std::pair<HGTD::ClusterTruthOrigin, bool>> shadowed_origins;
 
  for (const auto& rdo_id : rdo_id_list) {
 
    ATH_MSG_DEBUG("[ClusterTruthTool] looking for ID:" << rdo_id);
 
    auto pos = sim_data->find(rdo_id);
    // the InDetSimData contains a std::pair<HepMcParticleLink, float>, where
    // the second entry in the pair holds the time of the SiChargedDiode
    if (pos == sim_data->end()) {
      ATH_MSG_DEBUG(
          "[HGTD::ClusterTruthTool::classifyCluster] ID not found in SDO "
          "map, going to next ID");
      continue;
    }
    // collect deposits, sorted with first deposit at start of map bu default
    std::map<float, HGTD::ClusterTruthOrigin> sorted_deposits;

    // the following is taken from 20.20 as is
    ATH_MSG_DEBUG("[ClusterTruthTool] going through "
                  << pos->second.getdeposits().size() << " deposits");
    for (const auto& deposit : pos->second.getdeposits()) {
      const HepMcParticleLink& particle_link = deposit.first;
 
      // check for identity with original particle
      HepMC::ConstGenParticlePtr gen_part = particle_link.cptr();
 
      // HepMcParticleLinks with uniqueIDs equal to
      // HepMC::UNDEFINED_ID (used for detector noise, delta rays and
      // random energy deposits) or secondaries generated by GEANT4.
      if (HepMC::uniqueID(particle_link) == HepMC::UNDEFINED_ID ||
          (gen_part && HepMC::is_simulation_particle(gen_part))) {
        sorted_deposits.emplace(deposit.second, HGTD::ClusterTruthOrigin::SECONDARY);
        continue;
      }
      if (gen_part) {
        TLorentzVector l4(gen_part->momentum().px(), gen_part->momentum().py(),
                          gen_part->momentum().pz(), gen_part->momentum().e());
        // flag if this deposit came from the tested truth particle
        if (HepMC::is_same_particle(gen_part,tp) && tp->p4().DeltaR(l4) < 0.05) {
          sorted_deposits.emplace(deposit.second,
                                  HGTD::ClusterTruthOrigin::TRUTH_PARTICLE);
          // otherwise if given, the parent event can be checked
        } else if (hard_scatter_evnt and
                   gen_part->parent_event() == hard_scatter_evnt) {
          sorted_deposits.emplace(deposit.second,
                                  HGTD::ClusterTruthOrigin::HARD_SCATTER);
          // otherwise, a particle that was generated but doesn't come from the
          // hard scatter is considered to be originating from a pileup
          // interaction
        } else {
          sorted_deposits.emplace(deposit.second,
                                  HGTD::ClusterTruthOrigin::PILEUP);
        }
      } else {
        // if there is no gen particle, we can guess based on the event index
        if (particle_link.eventIndex() == 0) {
          sorted_deposits.emplace(deposit.second,
                                  HGTD::ClusterTruthOrigin::HARD_SCATTER);
        } else {
          // If the gen was not kept, we assume it is cut away from truth record
          // and is pileup
          sorted_deposits.emplace(deposit.second,
                                  HGTD::ClusterTruthOrigin::PILEUP);
        }
      }
    } // END lOOP over the deposits
 
    ATH_MSG_DEBUG("[ClusterTruthTool] " << sorted_deposits.size()
                                        << " sorted_deposits");
 
    // check for shadowing, which means that a deposit was left by the truth
    // particle, but it was not the first deposit and is thus not used for the
    // time measurement -> I will have an incorrect time
    bool is_shadowed = false;
    HGTD::ClusterTruthOrigin current_origin = HGTD::ClusterTruthOrigin::UNIDENTIFIED;
 
    std::map<float, HGTD::ClusterTruthOrigin>::iterator elem =
        sorted_deposits.begin();
 
    for (; elem != sorted_deposits.end(); ++elem) {
      if (elem == sorted_deposits.begin()) {
        current_origin = elem->second;
      } else {
        // if one of the later deposits originates from the truth particle, then
        // the hit I want to find was shadowed by something else, and I will
        // reconstruct an incorrect time
        if (current_origin != HGTD::ClusterTruthOrigin::TRUTH_PARTICLE &&
            elem->second == HGTD::ClusterTruthOrigin::TRUTH_PARTICLE) {
          is_shadowed = true;
        }
      }
    } // END LOOP over the time sorted deposits
    shadowed_origins.emplace_back(current_origin, is_shadowed);
  } // END LOOP over RDO identifiers
 
  HGTD::ClusterTruthInfo result;
 
  if (shadowed_origins.empty()) {
    ATH_MSG_DEBUG("did not manage to understand any RDOs...");
    result.origin = HGTD::ClusterTruthOrigin::UNIDENTIFIED;
    result.is_shadowed = false;
    // A cluster is considered to be merged if more than one particle deposited
    // energy in a given pad.
    result.is_merged = false;
  } else {
    result.is_merged = false;
    result.origin = shadowed_origins.at(0).first;
    result.is_shadowed = shadowed_origins.at(0).second;
    for (size_t i = 1; i < shadowed_origins.size(); ++i) {
      if (shadowed_origins.at(i).first != result.origin) {
        result.is_merged = true;
      } else {
        result.is_shadowed |= shadowed_origins.at(i).second;
      }
    }
  }
  return result;
}