CalcPartonHistory.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/

 
#ifndef PARTONS_CALCPARTONHISTORY_H
#define PARTONS_CALCPARTONHISTORY_H
 
// system include(s):
#include <array>
#include <vector>
 
// Framework include(s):
#include <xAODEventInfo/EventInfo.h>
 
#include "AsgTools/AsgTool.h"
#include <AsgTools/PropertyWrapper.h>
#include "PartonHistory/PartonHistoryUtils.h"
#include "PartonHistory/PartonSchemeConfig.h"
#include "VectorHelpers/DecoratorHelpers.h"
#include "xAODTruth/TruthParticleContainer.h"
 
namespace CP {
using ROOT::Math::PtEtaPhiMVector;
 
class CalcPartonHistory : public asg::AsgTool {
 
 public:
  explicit CalcPartonHistory(
      const std::string& name,
      const std::vector<std::string>& truthCollections = {"TruthTop"});
  virtual ~CalcPartonHistory() = default;
 
  CalcPartonHistory(const CalcPartonHistory& rhs) = delete;
  CalcPartonHistory(CalcPartonHistory&& rhs) = delete;
  CalcPartonHistory& operator=(const CalcPartonHistory& rhs) = delete;
  CalcPartonHistory& operator=(CalcPartonHistory&& rhs) = delete;
 
  void AddToParticleMap(const xAOD::TruthParticle* particle,
                        const std::string& key);
  bool ExistsInMap(const std::string& key) const;
  bool ExistsInKey(const std::string& key,
                   const xAOD::TruthParticle* particle) const;
  bool Retrievep4(const std::string& key, PtEtaPhiMVector& p4);
  bool Retrievep4(const std::string& key, PtEtaPhiMVector& p4, std::size_t idx);
  bool Retrievep4Gamma(PtEtaPhiMVector& p4, int& parentpdgId);
  bool RetrievepdgId(const std::string& key, std::vector<int>& pdgIds);
  bool RetrievepdgId(const std::string& key, int& pdgId);
  bool RetrievepdgId(const std::string& key, int& pdgId, std::size_t idx);
  bool RetrieveParticleInfo(const std::string& prefix,
                            std::vector<const xAOD::TruthParticle*>& particles);
  bool RetrieveParticleInfo(const std::string& prefix,
                            PtEtaPhiMVector& particle, int& pdgId);
  bool RetrieveParticleInfo(const std::string& prefix,
                            PtEtaPhiMVector& particle, int& pdgId,
                            std::size_t idx);
  bool RetrieveParticleInfo(const std::string& prefix,
                            const std::string& alt_prefix,
                            PtEtaPhiMVector& particle, int& pdgId);
  bool RetrieveParticleInfo(const std::string& prefix,
                            std::vector<PtEtaPhiMVector>& particles,
                            std::vector<int>& pdgIds);
 
  void Initialize4TopDecorators();
  void InitializeTopDecorators(bool fcnc = false);
  void InitializeAntiTopDecorators(bool fcnc = false);
  void InitializeBottomDecorators();
  void InitializeVectorBottomDecorators();
  void InitializeAntiBottomDecorators();
  void InitializeVectorAntiBottomDecorators();
  void InitializeCharmDecorators();
  void InitializeVectorCharmDecorators();
  void InitializeAntiCharmDecorators();
  void InitializeVectorAntiCharmDecorators();
  void InitializeTtbarDecorators();
  void InitializeHiggsDecorators();
  void InitializePhotonDecorators();
  void InitializeZDecorators(int nZs = 1, bool extend = false);
  void InitializeWDecorators(int nWs = 1);
 
  std::string GetParticleType(const xAOD::TruthParticle* particle);
 
  void TraceParticle(
      const xAOD::TruthParticle* particle,
      std::vector<const xAOD::TruthParticle*>& currentPath,
      std::vector<std::vector<const xAOD::TruthParticle*>>& allPaths);
  void TraceParticles(const xAOD::TruthParticleContainer* truthParticles);
 
  void handleFSR(const xAOD::TruthParticle* particle, const std::string& newKey,
                 std::string& key);
  bool handleDecay(const xAOD::TruthParticle* particle, std::string& key,
                   int decayID);
 
  void FillParticleMap(
      std::vector<std::vector<const xAOD::TruthParticle*>>& allPaths);
 
  // Generic history fillers
  void FillGenericPartonHistory(const std::string& retrievalstring,
                                const std::string& decorationstring,
                                const int idx);
  void FillGenericPartonHistory(
      const std::vector<std::string>& retrievalStrings,
      const std::string& decorationstring, const int idx);
  void FillGenericPartonHistory(
      const std::vector<std::string>& retrievalStrings,
      const std::string& decorationstring);
  void FillGenericVectorPartonHistory(const std::string& retrievalstring,
                                      const std::string& decorationstring);
 
  // Specialised history fillers
  void FillGammaPartonHistory();
  void FillZPartonHistory(const std::string& parent, int nZs = 1,
                          const std::string& mode = "resonant");
  void FillZtautauPartonHistory(const std::string& parent, int nZs = 1,
                                const std::string& mode = "resonant");
  void FillWPartonHistory(const std::string& parent, int nWs = 1,
                          const std::string& mode = "resonant");
  void FillXPartonHistory(const std::string& parent,            // for FCNC t -> qX, where X can be W
                          const std::string& symbolX);
  void FillTopPartonHistory(bool fcnc = false);
  void FillAntiTopPartonHistory(bool fcnc = false);
  void FillHiggsPartonHistory(const std::string& mode);
  void FillTtbarPartonHistory(bool fcnc = false);
 
  // Helpers for non-resonant / off-shell reconstruction.
  void setHiggs(const std::string& fsr);
  void setW(const std::string& fsr, int nWs);
  bool getW(const std::string& str_lep, const std::string& str_nu,
            PtEtaPhiMVector& p1, int& pdgId1, PtEtaPhiMVector& p2, int& pdgId2);
  void setZ(const std::string& fsr, int nZs);
  void setZtautau(const std::string& fsr, int nZs);
  bool getZ(const std::string& str_lep1, const std::string& str_lep2,
            PtEtaPhiMVector& p1, int& pdgId1, PtEtaPhiMVector& p2, int& pdgId2);
  struct ZTauTauProduct {
    PtEtaPhiMVector p4;
    int pdgId = 0;
    bool found = false;
  };

  struct ZTauTauDecay {
    std::array<ZTauTauProduct, 2> taus;
    std::array<std::array<ZTauTauProduct, 3>, 2> tauDecays;
  };
  ZTauTauDecay getZFromTaus(const std::string& fsr);

#ifndef XAOD_STANDALONE
  using AsgTool::configure;
#endif
  void configure(const PartonSchemeConfig& config);
 
  virtual StatusCode initialize() override;
  StatusCode execute();
 
 protected:
  std::map<std::string, std::vector<const xAOD::TruthParticle*>> m_particleMap;
  PartonDecorator m_dec;
 
  const std::vector<std::string> m_truthCollections;
  Gaudi::Property<std::string> m_prefix{
      this, "prefix", "", "Prefix to apply to all names to avoid overwriting"};
  Gaudi::Property<std::string> m_symbolFCNC{
      this, "symbolFCNC", "",
      "Symbol for FCNC, valid only for 'TtbarFCNC' history"};
 
  // this method is used to perform the linking of various TRUTH3 particle
  // containers for Partons to work
  virtual StatusCode linkTruthContainers(
      const xAOD::TruthParticleContainer*& tp);
 
  // this is the method that runs the actual parton history reconstruction
  virtual StatusCode runHistorySaver(
      const xAOD::TruthParticleContainer* truthParticles,
      const xAOD::EventInfo* ttbarPartonHistory);
 
  virtual void initializeDecorators();
 
  PartonSchemeConfig m_config;  
  bool m_configured = false;    

  StatusCode buildContainerFromMultipleCollections(
      const std::vector<std::string>& collections,
      const std::string& out_contName);

  StatusCode linkBosonCollections();

  const xAOD::TruthParticle* getTruthParticleLinkedFromDecoration(
      const xAOD::TruthParticle* part, const std::string& decorationName);
 
 private:
  StatusCode decorateCollectionWithLinksToAnotherCollection(
      const std::string& collectionToDecorate,
      const std::string& collectionToLink, const std::string& nameOfDecoration);
};
 
}  // namespace CP
 
#endif