#include <GepJetAlg.h>

Inheritance diagram for GepJetAlg:

Collaboration diagram for GepJetAlg:

Public Member Functions
	GepJetAlg (const std::string &name, ISvcLocator *pSvcLocator)
virtual StatusCode	initialize () override
virtual StatusCode	execute (const EventContext &) const override
virtual StatusCode	sysInitialize () override
	Override sysInitialize.
virtual bool	isClonable () const override
	Specify if the algorithm is clonable.
virtual StatusCode	sysExecute (const EventContext &ctx) override
	Execute an algorithm.
virtual const DataObjIDColl &	extraOutputDeps () const override
	Return the list of extra output dependencies.
virtual bool	filterPassed (const EventContext &ctx) const
	Get filter decision:
virtual void	setFilterPassed (bool state, const EventContext &ctx) const
	Set filter decision:
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard `StoreGateSvc` (event store) Returns (kind of) a pointer to the `StoreGateSvc`.
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard `StoreGateSvc/DetectorStore` Returns (kind of) a pointer to the `StoreGateSvc`.
virtual StatusCode	sysStart () override
	Handle START transition.
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles.
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T, V, H > &t)
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
bool	msgLvl (const MSG::Level lvl) const

Protected Member Functions
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void >	renounce (T &h)
void	extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
	Add StoreName to extra input/output deps as needed.

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
StatusCode	configureLRJMaker ()
template<typename Container, typename KinFn>
StatusCode	loadLRJSeeds (const SG::ReadHandleKey< Container > &key, const EventContext &ctx, KinFn &&kin, std::vector< Gep::Jet > &seeds) const
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
Gaudi::Property< std::string >	m_jetAlgName
Gaudi::Property< bool >	m_configureLRJMaker
SG::ReadHandleKey< xAOD::CaloClusterContainer >	m_caloClustersKey
SG::ReadHandleKey< xAOD::jFexSRJetRoIContainer >	m_jFexSRJetsKey
SG::WriteHandleKey< xAOD::JetContainer >	m_outputGepJetsKey
Gaudi::Property< float >	m_WTAConstEtCut
Gaudi::Property< float >	m_WTASeedEtCut
Gaudi::Property< float >	m_WTAJet_dR
Gaudi::Property< unsigned int >	m_WTAMaxConstN
Gaudi::Property< unsigned int >	m_WTAMaxSeedSortingN
Gaudi::Property< unsigned int >	m_WTABlockN
Gaudi::Property< std::string >	m_WTASeedCleaningName
SG::ReadHandleKey< xAOD::JetContainer >	m_lrjWTAConeSeedsKey
SG::ReadHandleKey< xAOD::gFexJetRoIContainer >	m_lrjGFexSRJetsKey
Gaudi::Property< std::string >	m_LRJSeedSource
Gaudi::Property< std::string >	m_LRJConstSource
Gaudi::Property< unsigned int >	m_LRJAlgoVersion
Gaudi::Property< float >	m_LRJJetR
Gaudi::Property< float >	m_LRJDSearch
Gaudi::Property< unsigned int >	m_LRJNSeedsInput
Gaudi::Property< unsigned int >	m_LRJNProtoSeeds
Gaudi::Property< unsigned int >	m_LRJNSeedsOutput
Gaudi::Property< unsigned int >	m_LRJMaxObjectsConsidered
Gaudi::Property< unsigned int >	m_LRJEtBitLength
Gaudi::Property< unsigned int >	m_LRJEtaBitLength
Gaudi::Property< unsigned int >	m_LRJPhiBitLength
Gaudi::Property< unsigned int >	m_LRJNumSubjetsLength
Gaudi::Property< unsigned int >	m_LRJNSubjetinessBitLength
Gaudi::Property< unsigned int >	m_LRJMassApproxBitLength
Gaudi::Property< unsigned int >	m_LRJPsiRBitLength
Gaudi::Property< unsigned int >	m_LRJDeltaRLutLength
Gaudi::Property< float >	m_LRJPhiMin {this, "LRJPhiMin", -9999.0, "phi range minimum. -9999 inherits the preset."}
Gaudi::Property< float >	m_LRJPhiMax {this, "LRJPhiMax", -9999.0, "phi range maximum. -9999 inherits the preset."}
Gaudi::Property< float >	m_LRJEtaMin {this, "LRJEtaMin", -9999.0, "eta range minimum. -9999 inherits the preset."}
Gaudi::Property< float >	m_LRJEtaMax {this, "LRJEtaMax", -9999.0, "eta range maximum. -9999 inherits the preset."}
Gaudi::Property< float >	m_LRJEtMin {this, "LRJEtMin", -9999.0, "Et range minimum (GeV). -9999 inherits the preset."}
Gaudi::Property< float >	m_LRJEtMax {this, "LRJEtMax", -9999.0, "Et range maximum (GeV). -9999 inherits the preset."}
Gaudi::Property< float >	m_LRJMassApproxMax {this, "LRJMassApproxMax", -1.0, "massApprox range maximum (GeV). <=0 inherits the preset."}
Gaudi::Property< float >	m_LRJInputEtToGeV {this, "LRJInputEtToGeV", -1.0, "Input Et (MeV) -> GeV scale. <=0 inherits the preset (1e-3)."}
Gaudi::Property< float >	m_LRJSubjetEtThresholdGeV
Gaudi::Property< float >	m_LRJMinEtSeedPosOptCutGeV
Gaudi::Property< float >	m_LRJSeedEtCutGeV
Gaudi::Property< float >	m_LRJConstEtCutGeV
Gaudi::Property< bool >	m_LRJEnableOverlapRemoval
Gaudi::Property< bool >	m_LRJEnableEtWeightedMidpoint
Gaudi::Property< bool >	m_LRJMinEtSeedPosOptimization
Gaudi::Property< bool >	m_LRJWriteSubstructure
Gaudi::Property< bool >	m_LRJWriteSubjetKinematics
Gaudi::Property< bool >	m_LRJWriteConstituentIndices
Gep::JetTaggerLRJMaker	m_lrjMaker
DataObjIDColl	m_extendedExtraObjects
	Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks.
StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default).
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default).
std::vector< SG::VarHandleKeyArray * >	m_vhka
bool	m_varHandleArraysDeclared

Detailed Description

Definition at line 35 of file GepJetAlg.h.

Member Typedef Documentation

◆ StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::StoreGateSvc_t

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

◆ GepJetAlg()

GepJetAlg::GepJetAlg	(	const std::string &	name,
		ISvcLocator *	pSvcLocator )

Definition at line 28 of file GepJetAlg.cxx.

                                                                      :
    AthReentrantAlgorithm( name, pSvcLocator ){
 
}

Member Function Documentation

◆ configureLRJMaker()

StatusCode GepJetAlg::configureLRJMaker ( )

private

Definition at line 64 of file GepJetAlg.cxx.

                                        {
 
  // All JetTaggerLRJ settings are resolved in Python (GepJetTaggerLRJAlgCfg
  // layers the BasicV2 / AdvancedV3 preset under any user overrides), so the
  // properties are already concrete: copy them straight into the config.
  Gep::JetTaggerLRJConfig cfg;
  cfg.algoVersion = m_LRJAlgoVersion;
 
  // Geometry.
  cfg.r2Cut     = static_cast<double>(m_LRJJetR) * static_cast<double>(m_LRJJetR);
  cfg.rMergeCut = m_LRJDSearch;
 
  // Multiplicities.
  cfg.nSeedsInput          = m_LRJNSeedsInput;
  cfg.nProtoSeeds          = m_LRJNProtoSeeds;
  cfg.nSeedsOutput         = m_LRJNSeedsOutput;
  cfg.maxObjectsConsidered = m_LRJMaxObjectsConsidered;
 
  // Digitization bit lengths.
  cfg.et_bit_length            = m_LRJEtBitLength;
  cfg.eta_bit_length           = m_LRJEtaBitLength;
  cfg.phi_bit_length           = m_LRJPhiBitLength;
  cfg.num_subjets_length       = m_LRJNumSubjetsLength;
  cfg.N_subjetiness_bit_length = m_LRJNSubjetinessBitLength;
  cfg.mass_approx_bit_length   = m_LRJMassApproxBitLength;
  cfg.psi_R_bit_length         = m_LRJPsiRBitLength;
  cfg.deltaR_lut_length        = m_LRJDeltaRLutLength;
 
  // Physical ranges.
  cfg.phi_min        = m_LRJPhiMin;
  cfg.phi_max        = m_LRJPhiMax;
  cfg.eta_min        = m_LRJEtaMin;
  cfg.eta_max        = m_LRJEtaMax;
  cfg.et_min         = m_LRJEtMin;
  cfg.et_max         = m_LRJEtMax;
  cfg.massApprox_max = m_LRJMassApproxMax;
  cfg.inputEtToGeV   = m_LRJInputEtToGeV;
 
  // Thresholds.
  cfg.subjetEtThresholdGeV  = m_LRJSubjetEtThresholdGeV;
  cfg.minEtSeedPosOptCutGeV = m_LRJMinEtSeedPosOptCutGeV;
 
  // Flow / output toggles.
  cfg.enableOverlapRemoval     = m_LRJEnableOverlapRemoval;
  cfg.enableEtWeightedMidpoint = m_LRJEnableEtWeightedMidpoint;
  cfg.minEtSeedPosOptimization = m_LRJMinEtSeedPosOptimization;
  cfg.writeSubstructure        = m_LRJWriteSubstructure;
  cfg.writeSubjetKinematics    = m_LRJWriteSubjetKinematics;
  cfg.writeConstituentIndices  = m_LRJWriteConstituentIndices;
 
  // Digitization must be fully specified (Python supplies the preset); a zero
  // in these fields means the algorithm was built without GepJetTaggerLRJAlgCfg,
  // which would make computeDerived() produce nonsense granularities
  if (cfg.et_bit_length == 0 || cfg.eta_bit_length == 0 ||
      cfg.phi_bit_length == 0 || cfg.deltaR_lut_length == 0) {
    ATH_MSG_ERROR("JetTaggerLRJ digitization not configured (et/eta/phi/deltaR "
                  "bit length is 0); configure it via GepJetTaggerLRJAlgCfg.");
    return StatusCode::FAILURE;
  }
 
  // Fill derived constants and build the deltaR LUT once.
  cfg.computeDerived();
  m_lrjMaker.m_cfg = cfg;
 
  // Seed source: resolve the string to an enum once (no silent fallback) and
  // require the matching input collection to be configured. Doing this here, in
  // initialize(), means a bad seed/key combination fails at configure time
  // rather than mid-event.
  if (m_LRJSeedSource == "WTACone") {
    m_lrjMaker.SetSeedSource(Gep::JetTaggerSeedSource::WTACone);
    if (m_lrjWTAConeSeedsKey.key().empty()) {
      ATH_MSG_ERROR("LRJSeedSource=WTACone requires LRJWTAConeSeedsKey to be set");
      return StatusCode::FAILURE;
    }
  } else if (m_LRJSeedSource == "jFexSRJ") {
    m_lrjMaker.SetSeedSource(Gep::JetTaggerSeedSource::jFexSRJ);
    if (m_jFexSRJetsKey.key().empty()) {
      ATH_MSG_ERROR("LRJSeedSource=jFexSRJ requires jFexSRJetRoIs to be set");
      return StatusCode::FAILURE;
    }
  } else if (m_LRJSeedSource == "gFexSRJ") {
    m_lrjMaker.SetSeedSource(Gep::JetTaggerSeedSource::gFexSRJ);
    if (m_lrjGFexSRJetsKey.key().empty()) {
      ATH_MSG_ERROR("LRJSeedSource=gFexSRJ requires LRJgFexSRJetRoIs to be set");
      return StatusCode::FAILURE;
    }
  } else {
    ATH_MSG_ERROR("Unknown LRJSeedSource '" << m_LRJSeedSource.value() << "'");
    return StatusCode::FAILURE;
  }
 
  // Constituent source: same explicit resolution (no silent fallback).
  if (m_LRJConstSource == "WTACone") {
    m_lrjMaker.SetConstSource(Gep::JetTaggerConstSource::WTACone);
  } else if (m_LRJConstSource == "Towers") {
    m_lrjMaker.SetConstSource(Gep::JetTaggerConstSource::Towers);
  } else {
    ATH_MSG_ERROR("Unknown LRJConstSource '" << m_LRJConstSource.value() << "'");
    return StatusCode::FAILURE;
  }
 
  ATH_MSG_INFO("Configured JetTaggerLRJ (v" << cfg.algoVersion
               << ", seed=" << m_LRJSeedSource.value()
               << ", const=" << m_LRJConstSource.value()
               << "): r2Cut=" << cfg.r2Cut << ", rMergeCut=" << cfg.rMergeCut
               << ", deltaR LUT size=" << cfg.lutR_8b.size());
 
  return StatusCode::SUCCESS;
}

◆ declareGaudiProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareGaudiProperty	(	Gaudi::Property< T, V, H > &	hndl,
		const SG::VarHandleKeyType &	)

inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKey>

Definition at line 156 of file AthCommonDataStore.h.

  {
    return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                       hndl.value(), 
                                                       hndl.documentation());
 
  }

◆ declareProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareProperty ( Gaudi::Property< T, V, H > & t )

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

                                                                     {
    typedef typename SG::HandleClassifier<T>::type htype;
    return AthCommonDataStore<PBASE>::declareGaudiProperty(t, htype());
  }

◆ detStore()

const ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::detStore ( ) const

inlineinherited

The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 95 of file AthCommonDataStore.h.

95{ return m_detStore; }

AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_detStore

StoreGateSvc_t m_detStore

Definition AthCommonDataStore.h:393

◆ evtStore()

ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::evtStore ( )

inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 85 of file AthCommonDataStore.h.

85{ return m_evtStore; }

AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_evtStore

StoreGateSvc_t m_evtStore

Definition AthCommonDataStore.h:390

◆ execute()

StatusCode GepJetAlg::execute ( const EventContext & context ) const

overridevirtual

Definition at line 195 of file GepJetAlg.cxx.

                                                               {
  ATH_MSG_DEBUG ("Executing " << name() << "...");
  
  
  SG::WriteHandle<xAOD::JetContainer>
    h_outputJets = SG::makeHandle(m_outputGepJetsKey, context);
 
 
  CHECK(h_outputJets.record(std::make_unique<xAOD::JetContainer>(),
                std::make_unique<xAOD::JetAuxContainer>()));
    
  // read in clusters
  auto h_caloClusters = SG::makeHandle(m_caloClustersKey, context);
  CHECK(h_caloClusters.isValid());
  ATH_MSG_DEBUG("Read in " << h_caloClusters->size() << " clusters");
 
  const auto& clusters = *h_caloClusters; 
 
 
 
  std::vector<Gep::Cluster> gepClusters;
  std::transform(clusters.cbegin(),
         clusters.cend(),
         std::back_inserter(gepClusters),
         [](const auto& cluster){
           Gep::Cluster c(cluster->p4());
           // Keep the raw eta/phi (pre-TLorentzVector round-trip) so
           // JetTaggerLRJ can digitize the same values the emulation reads.
           c.etaInput = cluster->eta();
           c.phiInput = cluster->phi();
           return c;});
         
 
 
  // create a  jet maker
  std::unique_ptr<Gep::IJetMaker> jetMaker{};
  
 
  if ( m_jetAlgName=="ModAntikT" ) {
    jetMaker.reset(new Gep::ModAntikTJetMaker());
  }
  
  else if ( m_jetAlgName=="Cone" ) {
 
    // Use jJFexSR RoIs as seeds
    auto h_seeds = SG::makeHandle(m_jFexSRJetsKey, context);
    CHECK(h_seeds.isValid());
    ATH_MSG_DEBUG("No of seeds "<< h_seeds->size());
    jetMaker.reset(new Gep::ConeJetMaker(0.4, *h_seeds));
    
  } else if(m_jetAlgName=="WTACone"){ // Large block for the WTACone
 
    auto WTAConeJetMaker = std::make_unique<Gep::WTAConeJetMaker>(); // Default parameters for now
 
    #ifdef FLOATING_POINT_SIMULATION
      WTAConeJetMaker->m_GEPWTAParameters.SetConstEtCut(m_WTAConstEtCut * Athena::Units::GeV); // Set ConstEtCut to 2GeV
      WTAConeJetMaker->m_GEPWTAParameters.SetSeedEtCut(m_WTASeedEtCut * Athena::Units::GeV); // Set SeedEtCut to 5GeV by default
      WTAConeJetMaker->m_GEPWTAParameters.SetJet_dR(m_WTAJet_dR);
      WTAConeJetMaker->m_GEPWTAParameters.SetIso_dR(m_WTAJet_dR); // Default is Jet_dR = Iso_dR
    #else
      // float to int/bitwise conversion
      WTAConeJetMaker->m_GEPWTAParameters.SetConstEtCut(static_cast<unsigned int>(m_WTAConstEtCut * Athena::Units::GeV / LSB)); // Set ConstEtCut to 8 bits, LSB = 250 MeV
      WTAConeJetMaker->m_GEPWTAParameters.SetSeedEtCut(static_cast<unsigned int>(m_WTASeedEtCut * Athena::Units::GeV / LSB)); // Set SeedEtCut to 20 bits by default
      WTAConeJetMaker->m_GEPWTAParameters.SetJet_dR(static_cast<unsigned int>(m_WTAJet_dR * 10));
      WTAConeJetMaker->m_GEPWTAParameters.SetIso_dR(static_cast<unsigned int>(m_WTAJet_dR * 10));
    #endif
 
    WTAConeJetMaker->m_GEPWTAParameters.SetMaxConstN(m_WTAMaxConstN);
    WTAConeJetMaker->m_GEPWTAParameters.SetMaxSeedSortingN(m_WTAMaxSeedSortingN);
    WTAConeJetMaker->SetBlockN(m_WTABlockN);
 
    WTAConeJetMaker->SetSeedCleaningAlgo(0); // 0 = Baseline
    if(m_WTASeedCleaningName=="TwoPass")WTAConeJetMaker->SetSeedCleaningAlgo(1); // 1 = TwoPass
 
    jetMaker = std::move(WTAConeJetMaker);
  } // WTACone loop, will be updated as the WTAConeJets
  else if ( m_jetAlgName=="JetTaggerLRJ" ) {
 
    // ------------------------------------------------------------------
    // JetTaggerLRJ: modified seeded-cone large-R jet maker.
    // ------------------------------------------------------------------
 
    // ---- build seeds vector (Gep::Jet) ----
    // Seed source is validated in initialize(); dispatch on the resolved enum.
    // The sources differ only in the input collection and the (pt/et, mass)
    // accessor, which each per-case lambda supplies to loadLRJSeeds().
    std::vector<Gep::Jet> lrjSeeds;
    switch (m_lrjMaker.GetSeedSource()) {
      case Gep::JetTaggerSeedSource::WTACone:
        ATH_CHECK(loadLRJSeeds(m_lrjWTAConeSeedsKey, context,
            [](const xAOD::Jet* j) {
              return std::tuple{j->pt(), j->eta(), j->phi(), j->m()};
            }, lrjSeeds));
        break;
      case Gep::JetTaggerSeedSource::jFexSRJ:
        ATH_CHECK(loadLRJSeeds(m_jFexSRJetsKey, context,
            [](const xAOD::jFexSRJetRoI* j) {
              return std::tuple{static_cast<double>(j->et()), static_cast<double>(j->eta()), static_cast<double>(j->phi()), 0.0};
            }, lrjSeeds));
        break;
      case Gep::JetTaggerSeedSource::gFexSRJ:
        ATH_CHECK(loadLRJSeeds(m_lrjGFexSRJetsKey, context,
            [](const xAOD::gFexJetRoI* j) {
              return std::tuple{static_cast<double>(j->et()), static_cast<double>(j->eta()), static_cast<double>(j->phi()), 0.0};
            }, lrjSeeds));
        break;
    }
    ATH_MSG_DEBUG("JetTaggerLRJ loaded " << lrjSeeds.size() << " seeds ("
                  << m_LRJSeedSource.value() << ")");
 
    // ---- build constituents vector (Gep::Cluster) ----
    // Both "Towers" and "WTACone" constituent sources currently reuse the
    // input m_caloClustersKey container; runConfig.py points it at the
    // appropriate collection ("CellTower" or the WTACone output). When the
    // two need to differ at run time the maker takes std::vector<Gep::Cluster>
    // either way; adjust the wiring here without touching the maker.
    const std::vector<Gep::Cluster>& lrjConstituents = gepClusters;
 
    // Maker (and its deltaR LUT) is configured once in initialize().
    std::vector<Gep::LargeRJet> lrjs = m_lrjMaker.makeLargeRJets(lrjSeeds, lrjConstituents);
    ATH_MSG_DEBUG("JetTaggerLRJ produced " << lrjs.size() << " large-R jets");
 
    if (!lrjs.empty()) {
      for (const auto& lrj : lrjs) {
        std::unique_ptr<xAOD::Jet> xAODJet{new xAOD::Jet()};
        xAOD::Jet* p = xAODJet.get();
        h_outputJets->push_back(std::move(xAODJet));
 
        xAOD::JetFourMom_t p4;
        p4.SetPt (lrj.vec.Pt());
        p4.SetEta(lrj.vec.Eta());
        p4.SetPhi(lrj.vec.Phi());
        p4.SetM  (lrj.vec.M());
        p->setJetP4(p4);
 
        p->setAttribute("RCut",        lrj.radius);
        p->setAttribute("SeedEt",      lrj.seedEt);
        p->setAttribute("SeedEta",     lrj.seedEta);
        p->setAttribute("SeedPhi",     lrj.seedPhi);
        p->setAttribute("NSubjets",    lrj.nSubjets);
        p->setAttribute("Psi_R",       lrj.psi_R);
        p->setAttribute("Tau_1",       lrj.tau_1);
        p->setAttribute("Tau_2",       lrj.tau_2);
        p->setAttribute("Tau_21",      lrj.tau_21);
        p->setAttribute("MassApprox",  lrj.massApprox);
        // Per-subjet kinematics as indexed SCALAR attributes (SubjetEt0,
        // SubjetEt1, ...). std::vector<float> jet attributes do not round-trip
        // to the reader here (neither setAttribute nor auxdata), whereas
        // scalar attributes do; the reader reads back NSubjets of them.
        for (size_t is = 0; is < lrj.subjet_et.size(); ++is) {
          const std::string s = std::to_string(is);
          p->setAttribute(std::string("SubjetEt")  + s, lrj.subjet_et[is]);
          p->setAttribute(std::string("SubjetEta") + s, lrj.subjet_eta[is]);
          p->setAttribute(std::string("SubjetPhi") + s, lrj.subjet_phi[is]);
        }
 
        // Attach constituents (indices into the input cluster container) so the
        // reader's numConstituents()/getConstituents() populate, mirroring the
        // generic maker path below.
        for (const int i : lrj.constituentsIndices) {
          p->addConstituent(clusters.at(i));
        }
      }
    }
    return StatusCode::SUCCESS;
  }
  else {
    ATH_MSG_ERROR( "Unknown JetMaker " <<  m_jetAlgName);
    return StatusCode::FAILURE;
  }
 
  ATH_MSG_DEBUG( "jet maker: " << jetMaker->toString());
  
  std::vector<Gep::Jet> gepJets = jetMaker->makeJets( gepClusters );
  
  ATH_MSG_DEBUG("Number of jets found for " <<
         m_jetAlgName << " " <<gepJets.size());
 
  // if no jets were found, skip event
  if( gepJets.empty() ){
    return StatusCode::SUCCESS;
  }
  
  // store gep jets in athena format
  for(const auto& gjet: gepJets){
    
    std::unique_ptr<xAOD::Jet> xAODJet{new xAOD::Jet()};
    xAOD::Jet* p_xAODJet = xAODJet.get();
 
    // store the xAOD::Jet in the output container to prepare the Aux container
    // The move invalids the unique_ptr, but we still have the bare pointer
    // which allows the updating of the xAODJet from the gep jet data.
    h_outputJets->push_back(std::move(xAODJet));
    
    xAOD::JetFourMom_t p4;
    p4.SetPt(gjet.vec.Pt());
    p4.SetEta(gjet.vec.Eta());
    p4.SetPhi(gjet.vec.Phi());
    p4.SetM(gjet.vec.M());
 
    p_xAODJet->setJetP4(p4);
    
    p_xAODJet->setAttribute("RCut", gjet.radius);
    p_xAODJet->setAttribute("SeedEta", gjet.seedEta); // < gep attributes
    p_xAODJet->setAttribute("SeedPhi", gjet.seedPhi); //
    p_xAODJet->setAttribute("SeedEt", gjet.seedEt); //
    p_xAODJet->setAttribute("Ring0_Et", gjet.ring0_Et);
    p_xAODJet->setAttribute("Ring1_Et", gjet.ring1_Et);
    p_xAODJet->setAttribute("Ring2_Et", gjet.ring2_Et);
    p_xAODJet->setAttribute("Ring3_Et", gjet.ring3_Et);
    p_xAODJet->setAttribute("Ring4_Et", gjet.ring4_Et);
    p_xAODJet->setAttribute("Total_TobN", gjet.total_TobN);
    p_xAODJet->setAttribute("Ring0_TobN", gjet.ring0_TobN);
    p_xAODJet->setAttribute("Ring1_TobN", gjet.ring1_TobN);
    p_xAODJet->setAttribute("Ring2_TobN", gjet.ring2_TobN);
    p_xAODJet->setAttribute("Ring3_TobN", gjet.ring3_TobN);
    p_xAODJet->setAttribute("Ring4_TobN", gjet.ring4_TobN);
 
    for (const auto& i: gjet.constituentsIndices) {
      p_xAODJet->addConstituent(clusters.at(i));
    }
    
  }
    
  return StatusCode::SUCCESS;
}

◆ extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::extraDeps_update_handler ( Gaudi::Details::PropertyBase & ExtraDeps )

protectedinherited

Add StoreName to extra input/output deps as needed.

use the logic of the VarHandleKey to parse the DataObjID keys supplied via the ExtraInputs and ExtraOuputs Properties to add the StoreName if it's not explicitly given

◆ extraOutputDeps()

const DataObjIDColl & AthCommonAlgorithm< Gaudi::Algorithm >::extraOutputDeps ( ) const

overridevirtualinherited

Return the list of extra output dependencies.

This list is extended to include symlinks implied by inheritance relations.

Definition at line 89 of file AthCommonAlgorithm.cxx.

{
  // If we didn't find any symlinks to add, just return the collection
  // from the base class.  Otherwise, return the extended collection.
  if (!m_extendedExtraObjects.empty()) {
    return m_extendedExtraObjects;
  }
  return BaseAlg::extraOutputDeps();
}

◆ filterPassed()

virtual bool AthCommonAlgorithm< Gaudi::Algorithm >::filterPassed ( const EventContext & ctx ) const

inlinevirtualinherited

Get filter decision:

Definition at line 93 of file AthCommonAlgorithm.h.

                                                           {
    return execState( ctx ).filterPassed();
  }

◆ initialize()

StatusCode GepJetAlg::initialize ( )

overridevirtual

Definition at line 34 of file GepJetAlg.cxx.

                                 {
  ATH_MSG_INFO ("Initializing " << name() << "...");
  ATH_MSG_INFO ("Jet alg " << m_jetAlgName);
 
  // Initialize data access keys
  CHECK(m_caloClustersKey.initialize());
  CHECK(m_jFexSRJetsKey.initialize());
  CHECK(m_outputGepJetsKey.initialize());
 
  CHECK(m_lrjWTAConeSeedsKey.initialize(!m_lrjWTAConeSeedsKey.empty()));
  CHECK(m_lrjGFexSRJetsKey.initialize(!m_lrjGFexSRJetsKey.empty()));
 
  // Build the JetTaggerLRJ configuration (and its deltaR LUT) once, so it is
  // not recomputed per event. Gated on an explicit property (set by
  // GepJetTaggerLRJAlgCfg) rather than the mode string; guard that the two
  // agree so a misconfiguration fails loudly instead of silently skipping.
  if (m_configureLRJMaker != (m_jetAlgName == "JetTaggerLRJ")) {
    ATH_MSG_ERROR("EnableLRJMaker (" << m_configureLRJMaker.value()
                  << ") is inconsistent with jetAlgName '" << m_jetAlgName.value()
                  << "'; both must select JetTaggerLRJ together.");
    return StatusCode::FAILURE;
  }
  if (m_configureLRJMaker) {
    ATH_CHECK(configureLRJMaker());
  }
 
  return StatusCode::SUCCESS;
}

◆ inputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::inputHandles ( ) const

overridevirtualinherited

Return this algorithm's input handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

◆ isClonable()

virtual bool AthCommonAlgorithm< Gaudi::Algorithm >::isClonable ( ) const

inlineoverridevirtualinherited

Specify if the algorithm is clonable.

Only relevant for non-reentrant algorithms. Actual number of clones needs to be set via the "Cardinality" property.

Reimplemented in AFP_DigiTop, AlgB, AlgT, BCM_Digitization, CscDigitBuilder, CscDigitToCscRDO, G4AtlasAlg, G4RunAlg, HGTD_Digitization, HiveAlgBase, InDet::GNNSeedingTrackMaker, InDet::SCT_Clusterization, InDet::SiSPGNNTrackMaker, InDet::SiSPSeededTrackFinder, InDet::SiTrackerSpacePointFinder, ISF::SimKernelMT, ITk::StripDigitization, ITkPixelCablingAlg, ITkStripCablingAlg, LArHitEMapMaker, LArTTL1Maker, LUCID_DigiTop, LVL1::L1TopoSimulation, MergeCalibHits, MergeGenericMuonSimHitColl, MergeHijingPars, MergeMcEventCollection, MergeTrackRecordCollection, MergeTruthJets, MergeTruthParticles, MuonDigitizer, PileUpMTAlg, PixelDigitization, RoIBResultToxAOD, SCT_ByteStreamErrorsTestAlg, SCT_CablingCondAlgFromCoraCool, SCT_CablingCondAlgFromText, SCT_ConditionsParameterTestAlg, SCT_ConditionsSummaryTestAlg, SCT_ConfigurationConditionsTestAlg, SCT_Digitization, SCT_FlaggedConditionTestAlg, SCT_LinkMaskingTestAlg, SCT_MajorityConditionsTestAlg, SCT_ModuleVetoTestAlg, SCT_MonitorConditionsTestAlg, SCT_PrepDataToxAOD, SCT_RawDataToxAOD, SCT_ReadCalibChipDataTestAlg, SCT_ReadCalibDataTestAlg, SCT_RODVetoTestAlg, SCT_SensorsTestAlg, SCT_SiliconConditionsTestAlg, SCT_StripVetoTestAlg, SCT_TdaqEnabledTestAlg, SCT_TestCablingAlg, SCTEventFlagWriter, SCTRawDataProvider, SCTSiLorentzAngleTestAlg, SCTSiPropertiesTestAlg, SGInputLoader, Simulation::BeamEffectsAlg, TileHitVecToCnt, TileMuonFitter, TilePulseForTileMuonReceiver, TileRawChannelMaker, TRTDigitization, and ZDC_DigiTop.

Definition at line 68 of file AthCommonAlgorithm.h.

                                           {
    return true;
  }

◆ loadLRJSeeds()

template<typename Container, typename KinFn>

StatusCode GepJetAlg::loadLRJSeeds	(	const SG::ReadHandleKey< Container > &	key,
		const EventContext &	ctx,
		KinFn &&	kin,
		std::vector< Gep::Jet > &	seeds ) const

private

Definition at line 176 of file GepJetAlg.cxx.

                                                                   {
  auto h = SG::makeHandle(key, ctx);
  CHECK(h.isValid());
  seeds.reserve(seeds.size() + h->size());
  for (const auto* j : *h) {
    const auto [pt, eta, phi, m] = kin(j);
    Gep::Jet s;
    s.vec.SetPtEtaPhiM(pt, eta, phi, m);
    s.etaInput = eta;  // raw, pre-round-trip (see Jet.h / JetTaggerLRJ)
    s.phiInput = phi;
    seeds.push_back(std::move(s));
  }
  return StatusCode::SUCCESS;
}

◆ msg()

MsgStream & AthCommonMsg< Gaudi::Algorithm >::msg ( ) const

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

◆ msgLvl()

bool AthCommonMsg< Gaudi::Algorithm >::msgLvl ( const MSG::Level lvl ) const

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                               {
    return this->msgLevel(lvl);
  }

◆ outputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::outputHandles ( ) const

overridevirtualinherited

Return this algorithm's output handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

◆ renounce()

std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::renounce ( T & h )

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

  {
    h.renounce();
    PBASE::renounce (h);
  }

◆ renounceArray()

void AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::renounceArray ( SG::VarHandleKeyArray & handlesArray )

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                          {
    handlesArray.renounce();
  }

◆ setFilterPassed()

virtual void AthCommonAlgorithm< Gaudi::Algorithm >::setFilterPassed	(	bool	state,
		const EventContext &	ctx ) const

inlinevirtualinherited

Set filter decision:

Reimplemented in AthFilterAlgorithm.

Definition at line 99 of file AthCommonAlgorithm.h.

                                                                            {
    execState( ctx ).setFilterPassed( state );
  }

◆ sysExecute()

StatusCode AthCommonAlgorithm< Gaudi::Algorithm >::sysExecute ( const EventContext & ctx )

overridevirtualinherited

Execute an algorithm.

We override this in order to work around an issue with the Algorithm base class storing the event context in a member variable that can cause crashes in MT jobs.

Reimplemented in AthAnalysisAlgorithm.

Definition at line 80 of file AthCommonAlgorithm.cxx.

{
  return BaseAlg::sysExecute (ctx);
}

◆ sysInitialize()

StatusCode AthCommonAlgorithm< Gaudi::Algorithm >::sysInitialize ( )

overridevirtualinherited

Override sysInitialize.

Override sysInitialize from the base class.

Loop through all output handles, and if they're WriteCondHandles, automatically register them and this Algorithm with the CondSvc

Scan through all outputHandles, and if they're WriteCondHandles, register them with the CondSvc

Reimplemented from AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >.

Reimplemented in AthAnalysisAlgorithm, AthFilterAlgorithm, AthHistogramAlgorithm, HypoBase, InputMakerBase, and PyAthena::Alg.

Definition at line 60 of file AthCommonAlgorithm.cxx.

                                                      {
  StatusCode sc=AthCommonDataStore<AthCommonMsg<BaseAlg>>::sysInitialize();
 
  if (sc.isFailure()) {
    return sc;
  }
  
  ServiceHandle<ICondSvc> cs("CondSvc",name());
  for (auto h : outputHandles()) {
    if (h->isCondition() && h->mode() == Gaudi::DataHandle::Writer) {
      // do this inside the loop so we don't create the CondSvc until needed
      if ( cs.retrieve().isFailure() ) {
        ATH_MSG_WARNING("no CondSvc found: won't autoreg WriteCondHandles");
        return StatusCode::SUCCESS;
      }      
      if (cs->regHandle(this,*h).isFailure()) {
        sc = StatusCode::FAILURE;
        ATH_MSG_ERROR("unable to register WriteCondHandle " << h->fullKey()
                      << " with CondSvc");
      }
    }
  }
  return sc;  
}

◆ sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::sysStart ( )

overridevirtualinherited

Handle START transition.

We override this in order to make sure that conditions handle keys can cache a pointer to the conditions container.

◆ updateVHKA()

void AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::updateVHKA ( Gaudi::Details::PropertyBase & )

inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

                                               {
    // debug() << "updateVHKA for property " << p.name() << " " << p.toString() 
    //         << "  size: " << m_vhka.size() << endmsg;
    for (auto &a : m_vhka) {
      std::vector<SG::VarHandleKey*> keys = a->keys();
      for (auto k : keys) {
        k->setOwner(this);
      }
    }
  }

Member Data Documentation

◆ m_caloClustersKey

SG::ReadHandleKey< xAOD::CaloClusterContainer> GepJetAlg::m_caloClustersKey

private

Initial value:

{

this, "caloClustersKey", "", "key to read in a CaloCluster constainer"}

Definition at line 53 of file GepJetAlg.h.

53 {

54 this, "caloClustersKey", "", "key to read in a CaloCluster constainer"};

◆ m_configureLRJMaker

Gaudi::Property<bool> GepJetAlg::m_configureLRJMaker

private

Initial value:

{this, "EnableLRJMaker", false,
      "Build and configure the JetTaggerLRJ maker in initialize(). Set by "
      "GepJetTaggerLRJAlgCfg; must agree with jetAlgName == 'JetTaggerLRJ'."}

Definition at line 49 of file GepJetAlg.h.

                                         {this, "EnableLRJMaker", false,
      "Build and configure the JetTaggerLRJ maker in initialize(). Set by "
      "GepJetTaggerLRJAlgCfg; must agree with jetAlgName == 'JetTaggerLRJ'."};

◆ m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default).

Definition at line 393 of file AthCommonDataStore.h.

◆ m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default).

Definition at line 390 of file AthCommonDataStore.h.

◆ m_extendedExtraObjects

DataObjIDColl AthCommonAlgorithm< Gaudi::Algorithm >::m_extendedExtraObjects

privateinherited

Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks.

Empty if no symlinks were found.

Definition at line 108 of file AthCommonAlgorithm.h.

◆ m_jetAlgName

Gaudi::Property<std::string> GepJetAlg::m_jetAlgName

private

Initial value:

{this, "jetAlgName", "",

"Gep jet alg idenfifier"}

Definition at line 46 of file GepJetAlg.h.

46 {this, "jetAlgName", "",

47 "Gep jet alg idenfifier"};

◆ m_jFexSRJetsKey

SG::ReadHandleKey<xAOD::jFexSRJetRoIContainer> GepJetAlg::m_jFexSRJetsKey

private

Initial value:

{

this, "jFexSRJetRoIs", "L1_jFexSRJetRoISim", "key to read a L1 jet container"}

Definition at line 56 of file GepJetAlg.h.

56 {

57 this, "jFexSRJetRoIs", "L1_jFexSRJetRoISim", "key to read a L1 jet container"};

◆ m_LRJAlgoVersion

Gaudi::Property<unsigned int> GepJetAlg::m_LRJAlgoVersion

private

Initial value:

{this, "LRJAlgoVersion", 3,

"Algorithm variant / preset: 2 = basic (BasicV2), 3 = advanced (AdvancedV3)."}

Definition at line 107 of file GepJetAlg.h.

107 {this, "LRJAlgoVersion", 3,

108 "Algorithm variant / preset: 2 = basic (BasicV2), 3 = advanced (AdvancedV3)."};

◆ m_LRJConstEtCutGeV

Gaudi::Property<float> GepJetAlg::m_LRJConstEtCutGeV

private

Initial value:

{this, "LRJConstEtCutGeV", 2.0,

"Minimum constituent Et in GeV (reserved; not yet applied)."}

Definition at line 169 of file GepJetAlg.h.

169 {this, "LRJConstEtCutGeV", 2.0,

170 "Minimum constituent Et in GeV (reserved; not yet applied)."};

◆ m_LRJConstSource

Gaudi::Property<std::string> GepJetAlg::m_LRJConstSource

private

Initial value:

{this, "LRJConstSource", "Towers",

"Source of JetTaggerLRJ constituents. Options: Towers, WTACone"}

Definition at line 103 of file GepJetAlg.h.

103 {this, "LRJConstSource", "Towers",

104 "Source of JetTaggerLRJ constituents. Options: Towers, WTACone"};

◆ m_LRJDeltaRLutLength

Gaudi::Property<unsigned int> GepJetAlg::m_LRJDeltaRLutLength

private

Initial value:

{this, "LRJDeltaRLutLength", 0,

"deltaR granularity bit length. 0 inherits the preset."}

Definition at line 146 of file GepJetAlg.h.

146 {this, "LRJDeltaRLutLength", 0,

147 "deltaR granularity bit length. 0 inherits the preset."};

◆ m_LRJDSearch

Gaudi::Property<float> GepJetAlg::m_LRJDSearch

private

Initial value:

{this, "LRJDSearch", 2.0,
      "Seed-position-optimization search distance (rMergeCut); ignored when v2 (basic). "
      "Default 2.0. <0 inherits the preset (which is 0.001/disabled for basic)."}

Definition at line 114 of file GepJetAlg.h.

                                   {this, "LRJDSearch", 2.0,
      "Seed-position-optimization search distance (rMergeCut); ignored when v2 (basic). "
      "Default 2.0. <0 inherits the preset (which is 0.001/disabled for basic)."};

◆ m_LRJEnableEtWeightedMidpoint

Gaudi::Property<bool> GepJetAlg::m_LRJEnableEtWeightedMidpoint

private

Initial value:

{this, "LRJEnableEtWeightedMidpoint", false,

"Use Et-weighted midpoint in seed-position optimization."}

Definition at line 175 of file GepJetAlg.h.

175 {this, "LRJEnableEtWeightedMidpoint", false,

176 "Use Et-weighted midpoint in seed-position optimization."};

◆ m_LRJEnableOverlapRemoval

Gaudi::Property<bool> GepJetAlg::m_LRJEnableOverlapRemoval

private

Initial value:

{this, "LRJEnableOverlapRemoval", true,

"Enable overlap removal between the leading two seeds (advanced only)."}

Definition at line 173 of file GepJetAlg.h.

173 {this, "LRJEnableOverlapRemoval", true,

174 "Enable overlap removal between the leading two seeds (advanced only)."};

◆ m_LRJEtaBitLength

Gaudi::Property<unsigned int> GepJetAlg::m_LRJEtaBitLength

private

Initial value:

{this, "LRJEtaBitLength", 0,

"Eta field bit length. 0 inherits the preset."}

Definition at line 134 of file GepJetAlg.h.

134 {this, "LRJEtaBitLength", 0,

135 "Eta field bit length. 0 inherits the preset."};

◆ m_LRJEtaMax

Gaudi::Property<float> GepJetAlg::m_LRJEtaMax {this, "LRJEtaMax", -9999.0, "eta range maximum. -9999 inherits the preset."}

private

Definition at line 153 of file GepJetAlg.h.

153{this, "LRJEtaMax", -9999.0, "eta range maximum. -9999 inherits the preset."};

◆ m_LRJEtaMin

Gaudi::Property<float> GepJetAlg::m_LRJEtaMin {this, "LRJEtaMin", -9999.0, "eta range minimum. -9999 inherits the preset."}

private

Definition at line 152 of file GepJetAlg.h.

152{this, "LRJEtaMin", -9999.0, "eta range minimum. -9999 inherits the preset."};

◆ m_LRJEtBitLength

Gaudi::Property<unsigned int> GepJetAlg::m_LRJEtBitLength

private

Initial value:

{this, "LRJEtBitLength", 0,

"Et field bit length. 0 inherits the preset."}

Definition at line 132 of file GepJetAlg.h.

132 {this, "LRJEtBitLength", 0,

133 "Et field bit length. 0 inherits the preset."};

◆ m_LRJEtMax

Gaudi::Property<float> GepJetAlg::m_LRJEtMax {this, "LRJEtMax", -9999.0, "Et range maximum (GeV). -9999 inherits the preset."}

private

Definition at line 155 of file GepJetAlg.h.

155{this, "LRJEtMax", -9999.0, "Et range maximum (GeV). -9999 inherits the preset."};

◆ m_LRJEtMin

Gaudi::Property<float> GepJetAlg::m_LRJEtMin {this, "LRJEtMin", -9999.0, "Et range minimum (GeV). -9999 inherits the preset."}

private

Definition at line 154 of file GepJetAlg.h.

154{this, "LRJEtMin", -9999.0, "Et range minimum (GeV). -9999 inherits the preset."};

◆ m_lrjGFexSRJetsKey

SG::ReadHandleKey<xAOD::gFexJetRoIContainer> GepJetAlg::m_lrjGFexSRJetsKey

private

Initial value:

{
    this, "LRJgFexSRJetRoIs", "L1_gFexSRJetRoISim",
    "gFEX small-R jet RoIs used as JetTaggerLRJ seeds."}

Definition at line 94 of file GepJetAlg.h.

                                                              {
    this, "LRJgFexSRJetRoIs", "L1_gFexSRJetRoISim",
    "gFEX small-R jet RoIs used as JetTaggerLRJ seeds."};

◆ m_LRJInputEtToGeV

Gaudi::Property<float> GepJetAlg::m_LRJInputEtToGeV {this, "LRJInputEtToGeV", -1.0, "Input Et (MeV) -> GeV scale. <=0 inherits the preset (1e-3)."}

private

Definition at line 157 of file GepJetAlg.h.

157{this, "LRJInputEtToGeV", -1.0, "Input Et (MeV) -> GeV scale. <=0 inherits the preset (1e-3)."};

◆ m_LRJJetR

Gaudi::Property<float> GepJetAlg::m_LRJJetR

private

Initial value:

{this, "LRJJetR", 1.1,

"Large-R jet cone radius; r2Cut = LRJJetR^2. Default 1.1 (r2Cut=1.21). <=0 inherits the preset."}

Definition at line 111 of file GepJetAlg.h.

111 {this, "LRJJetR", 1.1,

112 "Large-R jet cone radius; r2Cut = LRJJetR^2. Default 1.1 (r2Cut=1.21). <=0 inherits the preset."};

◆ m_lrjMaker

Gep::JetTaggerLRJMaker GepJetAlg::m_lrjMaker

private

Definition at line 189 of file GepJetAlg.h.

◆ m_LRJMassApproxBitLength

Gaudi::Property<unsigned int> GepJetAlg::m_LRJMassApproxBitLength

private

Initial value:

{this, "LRJMassApproxBitLength", 0,

"massApprox field bit length. 0 inherits the preset."}

Definition at line 142 of file GepJetAlg.h.

142 {this, "LRJMassApproxBitLength", 0,

143 "massApprox field bit length. 0 inherits the preset."};

◆ m_LRJMassApproxMax

Gaudi::Property<float> GepJetAlg::m_LRJMassApproxMax {this, "LRJMassApproxMax", -1.0, "massApprox range maximum (GeV). <=0 inherits the preset."}

private

Definition at line 156 of file GepJetAlg.h.

156{this, "LRJMassApproxMax", -1.0, "massApprox range maximum (GeV). <=0 inherits the preset."};

◆ m_LRJMaxObjectsConsidered

Gaudi::Property<unsigned int> GepJetAlg::m_LRJMaxObjectsConsidered

private

Initial value:

{this, "LRJMaxObjectsConsidered", 0,

"Maximum number of constituents to load per event. 0 inherits the preset."}

Definition at line 128 of file GepJetAlg.h.

128 {this, "LRJMaxObjectsConsidered", 0,

129 "Maximum number of constituents to load per event. 0 inherits the preset."};

◆ m_LRJMinEtSeedPosOptCutGeV

Gaudi::Property<float> GepJetAlg::m_LRJMinEtSeedPosOptCutGeV

private

Initial value:

{this, "LRJMinEtSeedPosOptCutGeV", -1.0,

"Minimum proto-seed Et (GeV) for seed-position optimization. <0 inherits the preset."}

Definition at line 163 of file GepJetAlg.h.

163 {this, "LRJMinEtSeedPosOptCutGeV", -1.0,

164 "Minimum proto-seed Et (GeV) for seed-position optimization. <0 inherits the preset."};

◆ m_LRJMinEtSeedPosOptimization

Gaudi::Property<bool> GepJetAlg::m_LRJMinEtSeedPosOptimization

private

Initial value:

{this, "LRJMinEtSeedPosOptimization", true,

"Apply the minimum proto-seed Et cut in seed-position optimization."}

Definition at line 177 of file GepJetAlg.h.

177 {this, "LRJMinEtSeedPosOptimization", true,

178 "Apply the minimum proto-seed Et cut in seed-position optimization."};

◆ m_LRJNProtoSeeds

Gaudi::Property<unsigned int> GepJetAlg::m_LRJNProtoSeeds

private

Initial value:

{this, "LRJNProtoSeeds", 0,

"Number of proto-seeds for seed-position optimization. 0 inherits the preset."}

Definition at line 122 of file GepJetAlg.h.

122 {this, "LRJNProtoSeeds", 0,

123 "Number of proto-seeds for seed-position optimization. 0 inherits the preset."};

◆ m_LRJNSeedsInput

Gaudi::Property<unsigned int> GepJetAlg::m_LRJNSeedsInput

private

Initial value:

{this, "LRJNSeedsInput", 0,

"Number of input seeds considered per event. 0 inherits the preset."}

Definition at line 119 of file GepJetAlg.h.

119 {this, "LRJNSeedsInput", 0,

120 "Number of input seeds considered per event. 0 inherits the preset."};

◆ m_LRJNSeedsOutput

Gaudi::Property<unsigned int> GepJetAlg::m_LRJNSeedsOutput

private

Initial value:

{this, "LRJNSeedsOutput", 0,

"Number of output LRJs per event (typically 2). 0 inherits the preset."}

Definition at line 125 of file GepJetAlg.h.

125 {this, "LRJNSeedsOutput", 0,

126 "Number of output LRJs per event (typically 2). 0 inherits the preset."};

◆ m_LRJNSubjetinessBitLength

Gaudi::Property<unsigned int> GepJetAlg::m_LRJNSubjetinessBitLength

private

Initial value:

{this, "LRJNSubjetinessBitLength", 0,

"tau_1 / tau_2 field bit length. 0 inherits the preset."}

Definition at line 140 of file GepJetAlg.h.

140 {this, "LRJNSubjetinessBitLength", 0,

141 "tau_1 / tau_2 field bit length. 0 inherits the preset."};

◆ m_LRJNumSubjetsLength

Gaudi::Property<unsigned int> GepJetAlg::m_LRJNumSubjetsLength

private

Initial value:

{this, "LRJNumSubjetsLength", 0,

"n-subjets field bit length. 0 inherits the preset."}

Definition at line 138 of file GepJetAlg.h.

138 {this, "LRJNumSubjetsLength", 0,

139 "n-subjets field bit length. 0 inherits the preset."};

◆ m_LRJPhiBitLength

Gaudi::Property<unsigned int> GepJetAlg::m_LRJPhiBitLength

private

Initial value:

{this, "LRJPhiBitLength", 0,

"Phi field bit length. 0 inherits the preset."}

Definition at line 136 of file GepJetAlg.h.

136 {this, "LRJPhiBitLength", 0,

137 "Phi field bit length. 0 inherits the preset."};

◆ m_LRJPhiMax

Gaudi::Property<float> GepJetAlg::m_LRJPhiMax {this, "LRJPhiMax", -9999.0, "phi range maximum. -9999 inherits the preset."}

private

Definition at line 151 of file GepJetAlg.h.

151{this, "LRJPhiMax", -9999.0, "phi range maximum. -9999 inherits the preset."};

◆ m_LRJPhiMin

Gaudi::Property<float> GepJetAlg::m_LRJPhiMin {this, "LRJPhiMin", -9999.0, "phi range minimum. -9999 inherits the preset."}

private

Definition at line 150 of file GepJetAlg.h.

150{this, "LRJPhiMin", -9999.0, "phi range minimum. -9999 inherits the preset."};

◆ m_LRJPsiRBitLength

Gaudi::Property<unsigned int> GepJetAlg::m_LRJPsiRBitLength

private

Initial value:

{this, "LRJPsiRBitLength", 0,

"psi_R / deltaR-LUT field bit length. 0 inherits the preset."}

Definition at line 144 of file GepJetAlg.h.

144 {this, "LRJPsiRBitLength", 0,

145 "psi_R / deltaR-LUT field bit length. 0 inherits the preset."};

◆ m_LRJSeedEtCutGeV

Gaudi::Property<float> GepJetAlg::m_LRJSeedEtCutGeV

private

Initial value:

{this, "LRJSeedEtCutGeV", 5.0,

"Minimum seed Et in GeV (reserved; not yet applied)."}

Definition at line 167 of file GepJetAlg.h.

167 {this, "LRJSeedEtCutGeV", 5.0,

168 "Minimum seed Et in GeV (reserved; not yet applied)."};

◆ m_LRJSeedSource

Gaudi::Property<std::string> GepJetAlg::m_LRJSeedSource

private

Initial value:

{this, "LRJSeedSource", "WTACone",

"Source of JetTaggerLRJ seeds. Options: WTACone, jFexSRJ, gFexSRJ"}

Definition at line 100 of file GepJetAlg.h.

100 {this, "LRJSeedSource", "WTACone",

101 "Source of JetTaggerLRJ seeds. Options: WTACone, jFexSRJ, gFexSRJ"};

◆ m_LRJSubjetEtThresholdGeV

Gaudi::Property<float> GepJetAlg::m_LRJSubjetEtThresholdGeV

private

Initial value:

{this, "LRJSubjetEtThresholdGeV", -1.0,

"Minimum subjet Et (GeV) for counting nSubjets. <0 inherits the preset."}

Definition at line 160 of file GepJetAlg.h.

160 {this, "LRJSubjetEtThresholdGeV", -1.0,

161 "Minimum subjet Et (GeV) for counting nSubjets. <0 inherits the preset."};

◆ m_LRJWriteConstituentIndices

Gaudi::Property<bool> GepJetAlg::m_LRJWriteConstituentIndices

private

Initial value:

{this, "LRJWriteConstituentIndices", true,

"Fill constituentsIndices / mergedIndices on the output LRJ."}

Definition at line 185 of file GepJetAlg.h.

185 {this, "LRJWriteConstituentIndices", true,

186 "Fill constituentsIndices / mergedIndices on the output LRJ."};

◆ m_LRJWriteSubjetKinematics

Gaudi::Property<bool> GepJetAlg::m_LRJWriteSubjetKinematics

private

Initial value:

{this, "LRJWriteSubjetKinematics", true,

"Fill per-subjet (et, eta, phi) vectors on the output LRJ."}

Definition at line 183 of file GepJetAlg.h.

183 {this, "LRJWriteSubjetKinematics", true,

184 "Fill per-subjet (et, eta, phi) vectors on the output LRJ."};

◆ m_LRJWriteSubstructure

Gaudi::Property<bool> GepJetAlg::m_LRJWriteSubstructure

private

Initial value:

{this, "LRJWriteSubstructure", true,

"Fill psi_R / tau_1 / tau_2 / massApprox / nSubjets on the output LRJ."}

Definition at line 181 of file GepJetAlg.h.

181 {this, "LRJWriteSubstructure", true,

182 "Fill psi_R / tau_1 / tau_2 / massApprox / nSubjets on the output LRJ."};

◆ m_lrjWTAConeSeedsKey

SG::ReadHandleKey<xAOD::JetContainer> GepJetAlg::m_lrjWTAConeSeedsKey

private

Initial value:

{
    this, "LRJWTAConeSeedsKey", "",
    "WTACone small-R jets used as JetTaggerLRJ seeds (xAOD::JetContainer)."}

Definition at line 90 of file GepJetAlg.h.

                                                         {
    this, "LRJWTAConeSeedsKey", "",
    "WTACone small-R jets used as JetTaggerLRJ seeds (xAOD::JetContainer)."};

◆ m_outputGepJetsKey

SG::WriteHandleKey<xAOD::JetContainer> GepJetAlg::m_outputGepJetsKey

private

Initial value:

{
    this, "outputJetsKey", "",
    "key for xAOD:Jet wrappers for GepJets"}

Definition at line 59 of file GepJetAlg.h.

                                                       {
    this, "outputJetsKey", "",
    "key for xAOD:Jet wrappers for GepJets"};

◆ m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

◆ m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_vhka

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

◆ m_WTABlockN

Gaudi::Property<unsigned int> GepJetAlg::m_WTABlockN

private

Initial value:

{this, "WTABlockN", 4,

"Number of blocks to divide the input towers into for parallel processing. Options: 1, 4"}

Definition at line 79 of file GepJetAlg.h.

79 {this, "WTABlockN", 4,

80 "Number of blocks to divide the input towers into for parallel processing. Options: 1, 4"};

◆ m_WTAConstEtCut

Gaudi::Property<float> GepJetAlg::m_WTAConstEtCut

private

Initial value:

{this, "WTAConstEtCut", 2.0,

"Minimum Et for a tower to be considered as a constituent"}

Definition at line 64 of file GepJetAlg.h.

64 {this, "WTAConstEtCut", 2.0,

65 "Minimum Et for a tower to be considered as a constituent"};

◆ m_WTAJet_dR

Gaudi::Property<float> GepJetAlg::m_WTAJet_dR

private

Initial value:

{this, "WTAJet_dR", 0.4,

"Jet radius to determine TOB-Jet association"}

Definition at line 70 of file GepJetAlg.h.

70 {this, "WTAJet_dR", 0.4,

71 "Jet radius to determine TOB-Jet association"};

◆ m_WTAMaxConstN

Gaudi::Property<unsigned int> GepJetAlg::m_WTAMaxConstN

private

Initial value:

{this, "WTAMaxConstN", 205,

"Maximum number of constituents per jet"}

Definition at line 73 of file GepJetAlg.h.

73 {this, "WTAMaxConstN", 205,

74 "Maximum number of constituents per jet"};

◆ m_WTAMaxSeedSortingN

Gaudi::Property<unsigned int> GepJetAlg::m_WTAMaxSeedSortingN

private

Initial value:

{this, "WTAMaxSeedSortingN", 50,

"Maximum number of seeds to sort"}

Definition at line 76 of file GepJetAlg.h.

76 {this, "WTAMaxSeedSortingN", 50,

77 "Maximum number of seeds to sort"};

◆ m_WTASeedCleaningName

Gaudi::Property<std::string> GepJetAlg::m_WTASeedCleaningName

private

Initial value:

{this, "WTASeedCleaningName", "TwoPass",

"Seed cleaning algorithm to use. Options: Baseline, TwoPass"}

Definition at line 82 of file GepJetAlg.h.

82 {this, "WTASeedCleaningName", "TwoPass",

83 "Seed cleaning algorithm to use. Options: Baseline, TwoPass"};

◆ m_WTASeedEtCut

Gaudi::Property<float> GepJetAlg::m_WTASeedEtCut

private

Initial value:

{this, "WTASeedEtCut", 5.0,

"Minimum Et for a tower to be considered as a seed"}

Definition at line 67 of file GepJetAlg.h.

67 {this, "WTASeedEtCut", 5.0,

68 "Minimum Et for a tower to be considered as a seed"};

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

Public Member Functions

Protected Member Functions

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ StoreGateSvc_t

Constructor & Destructor Documentation

◆ GepJetAlg()

Member Function Documentation

◆ configureLRJMaker()

◆ declareGaudiProperty()

◆ declareProperty()

◆ detStore()

◆ evtStore()

◆ execute()

◆ extraDeps_update_handler()

◆ extraOutputDeps()

◆ filterPassed()

◆ initialize()

◆ inputHandles()

◆ isClonable()

◆ loadLRJSeeds()

◆ msg()

◆ msgLvl()

◆ outputHandles()

◆ renounce()

◆ renounceArray()

◆ setFilterPassed()

◆ sysExecute()

◆ sysInitialize()

◆ sysStart()

◆ updateVHKA()

Member Data Documentation

◆ m_caloClustersKey

◆ m_configureLRJMaker

◆ m_detStore

◆ m_evtStore

◆ m_extendedExtraObjects

◆ m_jetAlgName

◆ m_jFexSRJetsKey

◆ m_LRJAlgoVersion

◆ m_LRJConstEtCutGeV

◆ m_LRJConstSource

◆ m_LRJDeltaRLutLength

◆ m_LRJDSearch

◆ m_LRJEnableEtWeightedMidpoint

◆ m_LRJEnableOverlapRemoval

◆ m_LRJEtaBitLength

◆ m_LRJEtaMax

◆ m_LRJEtaMin

◆ m_LRJEtBitLength

◆ m_LRJEtMax

◆ m_LRJEtMin

◆ m_lrjGFexSRJetsKey

◆ m_LRJInputEtToGeV

◆ m_LRJJetR

◆ m_lrjMaker

◆ m_LRJMassApproxBitLength

◆ m_LRJMassApproxMax

◆ m_LRJMaxObjectsConsidered

◆ m_LRJMinEtSeedPosOptCutGeV

◆ m_LRJMinEtSeedPosOptimization

◆ m_LRJNProtoSeeds

◆ m_LRJNSeedsInput

◆ m_LRJNSeedsOutput

◆ m_LRJNSubjetinessBitLength

◆ m_LRJNumSubjetsLength

◆ m_LRJPhiBitLength

◆ m_LRJPhiMax

◆ m_LRJPhiMin

◆ m_LRJPsiRBitLength

◆ m_LRJSeedEtCutGeV

◆ m_LRJSeedSource

◆ m_LRJSubjetEtThresholdGeV

◆ m_LRJWriteConstituentIndices

◆ m_LRJWriteSubjetKinematics

◆ m_LRJWriteSubstructure

◆ m_lrjWTAConeSeedsKey