HGTD::ClusterTruthTool Class Reference

#include <ClusterTruthTool.h>

Inheritance diagram for HGTD::ClusterTruthTool:

Collaboration diagram for HGTD::ClusterTruthTool:

Public Member Functions
	ClusterTruthTool (const std::string &, const std::string &, const IInterface *)
virtual HGTD::ClusterTruthInfo	classifyCluster (const HGTD_Cluster *cluster, const xAOD::TruthParticle *tp, const InDetSimDataCollection *sim_data, const HepMC::GenEvent *hard_scatter_evnt=nullptr) const override final
	The InDetSimDataCollection is a map, connecting Identifiers from the RDOs to InDetSimData objects, that keep a vector of HepMcParticleLink, float pairs, where the float keeps the energy of the given energy deposit.

Detailed Description

Definition at line 25 of file ClusterTruthTool.h.

Constructor & Destructor Documentation

ClusterTruthTool()

HGTD::ClusterTruthTool::ClusterTruthTool	(	const std::string &	t,
		const std::string &	n,
		const IInterface *	p )

Definition at line 23 of file ClusterTruthTool.cxx.

    : base_class(t, n, p) {}

Member Function Documentation

classifyCluster()

HGTD::ClusterTruthInfo HGTD::ClusterTruthTool::classifyCluster ( const HGTD_Cluster * cluster, const xAOD::TruthParticle * tp, const InDetSimDataCollection * sim_data, const HepMC::GenEvent * hard_scatter_evnt = nullptr ) const

finaloverridevirtual

The InDetSimDataCollection is a map, connecting Identifiers from the RDOs to InDetSimData objects, that keep a vector of HepMcParticleLink, float pairs, where the float keeps the energy of the given energy deposit.

For HGTD, we store the time of the deposit instead, and can then select the first deposit, since only this one would contribute to the time read out by the ASIC.

Parameters

[in]	cluster	Hit in HGTD, for which we want the truth information.
[in]	tp	Truth particle that is potentially matched to the cluster.
[in]	sim_data	SDO collection storing the truth links of the charged diodes.
[in]	hard_scatter_evnt	If given, a cluster can be categorised as coming from the HS event, even if the direct match with the truth particle fails.

Returns

Struct combining the relevant truth information.

Definition at line 28 of file ClusterTruthTool.cxx.

                                                  {
 
  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;
}

---

The documentation for this class was generated from the following files:

• ClusterTruthTool.h
• ClusterTruthTool.cxx