PaperlayerView exact revision on arXiv

Source-linked AI summary

FastJet user manual

Matteo Cacciari, Gavin P. Salam, Gregory Soyez

arXiv:1111.6097v1hep-phhep-ex

TL;DR

Jet studies require efficient, broadly accessible algorithms and tools for high-multiplicity, multi-scale, and noisy collision environments. FastJet addresses this with optimized sequential-recombination implementations, cone-algorithm access, and jet-analysis tools, achieving expected N ln N timing and reducing N = 1000 clustering to a few milliseconds.

  • Problem

    Jet analysis needs efficient, precisely specified algorithms and tools for high-multiplicity, multi-scale, and contamination-prone collision environments.

  • Method

    FastJet provides efficient implementations of widely used sequential-recombination algorithms, cone-algorithm access, and tools for jet substructure, tagging, areas, and noise estimation.

  • Results

    Expected N ln N timing reduces clustering for N = 1000 from about 1 s to a few milliseconds for many sequential-recombination algorithms.

  • Takeaways & Limitations

    FastJet offers a practical framework for applying diverse jet algorithms and analyzing substructure and soft contamination in collider events.

Abstract

from arXiv · show

FastJet is a C++ package that provides a broad range of jet finding and analysis tools. It includes efficient native implementations of all widely used 2-to-1 sequential recombination jet algorithms for pp and e+e- collisions, as well as access to 3rd party jet algorithms through a plugin mechanism, including all currently used cone algorithms. FastJet also provides means to facilitate the manipulation of jet substructure, including some common boosted heavy-object taggers, as well as tools for estimation of pileup and underlying-event noise levels, determination of jet areas and subtraction or suppression of noise in jets.

A Clustering strategies and performance · 1 Introduction

FastJet is designed to make widely used jet algorithms accessible and efficient across collider environments. Its introduction emphasizes scalable sequential-recombination clustering, cone-algorithm access, and facilities for jets affected by high-energy structure and background noise.

  • 1 Introduction: Jet algorithms are broadly classified as sequential recombination or cone algorithms.Sequential methods repeatedly recombine closest pairs, whereas cone methods group particles within stable conical regions.
  • 1 Introduction: FastJet provides straightforward, efficient implementations of widely used sequential-recombination algorithms for hadron-hadron and e+e− colliders, plus access to cone-type algorithms.The library is distributed under version 2 of the GNU General Public License.
  • 1 Introduction: The kt algorithm illustrates FastJet’s terminology: clustering uses particle-pair and beam distances, with exclusive and inclusive formulations differing in their stopping treatment.Both formulations share the same clustering sequence up to dcut because their distance measures are identical.
  • 1 Introduction: N(N −1)/2 pair distances make naive clustering costly for N particles, motivating specialized implementations for hadron-collider events.The introduction notes that such events may contain several hundreds or even thousands of particles.
  • 1 Introduction: Expected N ln N timing is achieved for many sequential-recombination algorithms, with additional geometric implementations optimizing clustering up to N ≲30000.For N = 1000, timing is reduced to a few milliseconds.
  • 1 Introduction: FastJet also facilitates cone-algorithm use because cone methods were important in Tevatron and preparatory LHC studies, despite sequential algorithms dominating at the LHC.Straightforward cone-code access supports theoretical and phenomenological comparisons with those results.
  • 1 Introduction: The library extends beyond basic jet finding to address high-energy jet structure and contamination from pileup, underlying-event, and heavy-ion backgrounds.These environments can contain dense low-momentum contamination or over a TeV of transverse momentum per unit rapidity.
  • 1 Introduction: FastJet’s usage model combines a quick-start guide and core classes with user extensibility through plugins, selectors, tools, and related facilities.The quick-start guide appears in section 2, while PseudoJet, JetDefinition, and ClusterSequence are described in section 3.

2 Quick-start guide

The quick-start guide shows how to download, compile, install, and test FastJet, then demonstrates clustering a three-particle event with an anti-kt jet definition. It also reports the resulting jets and points to additional example programs in the distribution.

  • Setup: FastJet is downloaded as a versioned archive, unpacked, and entered after replacing X.Y.Z with the appropriate version number.The guide notes that wget may replace curl -O on some systems.
  • Setup: The package is configured with a user-selected prefix, compiled, checked, installed, and followed by returning to the original directory.The commands are ./configure, make, make check, make install, and cd ...
  • Example program: A short C++ example defines three particles, selects the anti-kt algorithm with R = 0.7, clusters them, and sorts the inclusive jets by transverse momentum.The example uses ClusterSequence and sorted_by_pt(cs.inclusive_jets()).
  • Example program: The example is compiled with fastjet-config flags and libraries, then run as short-example.The guide warns that PDF copy-and-paste can convert required back-quotes into forward quotes.
  • Example output: The output identifies the longitudinally invariant anti-kt algorithm with R = 0.7 and gives jet 0 as pt 103, y 0, phi 0 and jet 1 as pt 99, y 0, phi 3.14159.Jet 0 contains constituents with pt 99.0001 and 4.00125.
  • Further examples: More advanced example programs illustrating FastJet capabilities are available in the distribution’s example/ subdirectory.

3 Core classes

FastJet’s basic interface centers on PseudoJet, JetDefinition, and ClusterSequence: jets and inputs are represented as PseudoJets, clustering is specified by JetDefinition, and ClusterSequence performs clustering and exposes final jets. PseudoJet also supports kinematic access, user metadata, arithmetic and comparison operations, resetting, and sorting utilities.

  • Core classes: FastJet’s three main basic-usage classes are PseudoJet, JetDefinition, and ClusterSequence.PseudoJet represents jets and optionally input particles; JetDefinition specifies clustering; ClusterSequence performs clustering and provides access to final jets.
  • PseudoJet: PseudoJet stores four-momentum and internal clustering-context indices and can be constructed from components or a subscriptable Lorentz-vector type.The default constructor sets all momentum components to zero.
  • PseudoJet: PseudoJet exposes energy, momentum, angular, rapidity, transverse-momentum, mass, transverse-mass, and component-access functions, with multiple aliases for common quantities.The manual notes that this naming diversity reflects common community usage.
  • PseudoJet: User information can be attached through an integer user index or a PseudoJet::UserInfoBase-derived object, while reset functions either restore defaults or preserve other metadata.The full reset restores user and history indices and user information to defaults; reset_momentum changes only the four-momentum.
  • PseudoJet: PseudoJet supports arithmetic and equality operators, and helper routines sort vectors by decreasing transverse momentum, increasing rapidity, or decreasing energy.The sorting utilities are typically applied to jets returned by ClusterSequence.
  • JetDefinition: JetDefinition specifies the clustering algorithm, its parameters such as R, the recombination scheme, and the strategy; supported algorithms include kt, Cambridge, anti-kt, generalized kt, and e+e− variants.The generalized kt algorithms require an additional parameter p, while ee_kt_algorithm has no R parameter.

4 FastJet native jet algorithms

FastJet includes the longitudinally invariant kt jet algorithm, which has both inclusive and exclusive variants. The inclusive variant is formulated with reference to, subject to small notation changes.

  • Algorithm variants: FastJet’s longitudinally invariant kt jet algorithm has inclusive and exclusive variants.The passage introduces both forms before presenting the inclusive formulation.
  • Inclusive variant: The inclusive variant corresponds to reference, modulo small changes of notation.The passage states this correspondence explicitly.
  • Inclusive variant: The manual proceeds by formulating the inclusive longitudinally invariant kt algorithm.The formulation follows the introduction of the inclusive and exclusive variants.

1. For each pair of particles i, j work out the kt distance11

The longitudinally invariant kt algorithm repeatedly compares pairwise and beam distances, recombining the closest pair or declaring a beam-distance particle a final jet. Clustering continues until no particles remain, with an exclusive variant stopping at a specified dcut and assigning beam-distance particles to the beam jet.

  • Distance measures: The algorithm computes each pairwise distance from rapidity and azimuth differences, together with a beam distance for every particle and radius parameter R.The passage defines yi, φi, pti, and R, and introduces the beam distance diB.
  • Clustering procedure: The minimum among all dij and diB determines the next operation: pairwise minima trigger E-scheme four-momentum recombination, while beam minima finalize and remove the particle as a jet.This is the algorithm’s clustering decision rule.
  • Clustering procedure: The minimum-distance procedure repeats from the first step until no particles are left.This completes the inclusive clustering sequence.
  • Exclusive variant: In the exclusive variant, a smallest diB assigns the particle to the beam jet, and clustering stops when every dij and diB exceeds dcut.The exclusive mode commonly uses R = 1.
  • FastJet interface: The same clustering sequence supports inclusive jet extraction and exclusive jet extraction at a specified dcut through the ClusterSequence interface.The manual illustrates these operations with inclusive_jets() and exclusive_jets(dcut).

5 Plugin jet algorithms

FastJet’s plugin facility provides a common interface for incorporating almost any external jet algorithm and using FastJet analysis features with it. The SISCone plugin exemplifies this approach, offering stable-cone finding and split–merge controls, but with higher computational cost than native algorithms.

  • Plugin facility: The plugin facility incorporates almost any external jet algorithm within FastJet’s common framework, including access to features such as jet-area measurement.The stated exception is algorithms assigning one particle to multiple jets, such as ARCLUS.
  • Generic plugin use: Plugins derive from fastjet::JetDefinition::Plugin, and their JetDefinition objects can then be used identically to native JetDefinition objects.Users can transfer plugin ownership to JetDefinition with delete_unused().
  • SISCone: O(N^2) memory use and a few tenths of a second for N = 10^3 make SISCone about 100 times slower than native FastJet algorithms.These speed and memory figures are described as expected for a suitably random set of particles.
  • SISCone: SISCone identifies stable cones with an O(N^2 ln N) seedless search, then applies split–merge processing so no particle belongs to multiple jets.Its overlap threshold controls when overlapping protojets are merged, while multiple passes can recover cones containing particles absent from earlier stable cones.
  • SISCone: SISCone’s protojet_ptmin and overlap threshold can suppress low-pt protojets and discourage large “monster” jets in noisy events.A large overlap threshold, such as 0.75, helps disfavour monster-jet production through repeated merging.

6 Selectors

FastJet’s Selector class provides reusable jet-selection cuts that can be applied to individual jets or ensembles and combined through logical and sequential operations. Selectors also support specialized ensemble, reference-jet, geometric, and area-related behavior.

  • Reusable selections: The Selector class lets programs define reusable cuts on jet properties such as transverse momentum, rapidity, and the N hardest jets.Selectors are available through fastjet/Selector.hh.
  • Applying and combining selectors: Selectors applied to jet vectors return the jets passing the cuts, while &&, ||, and ! combine selections into compound selectors.Selector::pass(const PseudoJet &) tests individual jets, and Selector::sift separates passing and failing jets in ensembles.
  • Ensemble selections: SelectorNHardest(n) selects the n jets with largest transverse momenta, or all jets when the ensemble contains fewer than n.For ensemble selectors combined with logical operators, each constituent acts independently on the full ensemble; sequential composition applies the right-hand selector first.
  • Selector metadata: Selectors can expose rapidity extent, indicate whether they are geometric, and provide meaningful finite areas, including areas computed with ghosts.The area function uses ghost particles by default with ghost area 0.01, unless the user specifies another value.
  • Reference-jet selectors: Reference-jet selectors select jets using distances, regions, or transverse-momentum fractions relative to a reference jet.A missing reference causes an exception, while setting a reference on a compound selector propagates it to components that require one.

7 Jet areas

FastJet defines jet areas as measures of a jet’s extent in the y-φ plane and its susceptibility to soft contamination. It supports active, passive, and Voronoi definitions, with all agreeing in densely populated events, and provides tools for calculating and using areas in background estimation.

  • Jet areas measure a jet’s surface in the y-φ plane and its susceptibility to soft contamination.
  • Active areas use extremely soft ghosts to measure sensitivity to diffuse background noise, while passive areas use repeated single-ghost tests for point-like noise.
  • Voronoi areas sum constituent-particle Voronoi cells intersected with radius-R circles, coinciding with passive areas for kt but not generally for other algorithms.
  • FastJet obtains area information through AreaDefinition and ClusterSequenceArea, while JetMedianBackgroundEstimator and Subtractor support diffuse-noise estimation and subtraction.
  • Rfact ≃0.9 provides an acceptable approximation to the kt algorithm’s active area and is often significantly faster to compute than the active area.

8 Background estimation and subtraction

FastJet estimates diffuse event backgrounds using the median p_t/A of jets or grid cells, yielding background density and fluctuation measures for event-by-event correction. It supports subtraction of background contamination and rapidity-dependent techniques, with rescaling generally comparable to local estimation while less sensitive to many hard jets.

  • Background estimation: The standard background estimate ρ is the median of the p_t/A distribution for selected jets, largely insensitive to a handful of hard jets.The method is used to characterize diffuse background from underlying events or pileup on an event-by-event basis.
  • Background estimation: Grid-based estimation takes the median p_t/A of rectangular y–φ cells, providing a simpler and much faster alternative without practical corner-induced bias.Grid spacings of 0.5–0.7 are reported as adequate, with lower values preferred for high-multiplicity events.
  • Background estimation: The estimators provide ρ and σ, where σ is defined from the 1-sigma half-width of the p_t/A distribution and empty area contributes zero-p_t entries.If more than half the selected area is empty, the median ρ is roughly zero, as appropriate for quiet events.
  • Background subtraction: Subtraction normally returns jet − bge.rho(jet)·jet.area, while jets whose transverse momentum is below the estimated contamination are instead assigned zero four-momentum.The returned jet retains the original jet’s user and structural information.
  • Rapidity-dependent estimation: Rescaling generally performs comparably to local estimation in residual p_t dispersion after subtraction and is less sensitive to biases from high multiplicities of hard jets.These techniques address background-density dependence on rapidity and sometimes azimuth.

9 Jet transformers (substructure, taggers, etc...)

FastJet 3 provides a common Transformer interface for jet substructure, taggers, and noise-suppression tools, with returned jets exposing additional structural information. The section describes filtering, trimming, pruning, and included boosted-object taggers as concrete examples.

  • Transformer framework: FastJet 3 provides a common interface for post-clustering tools, simplifying their use and guiding the development of new taggers and noise-suppression methods.These tools address boosted-object tagging and suppression of underlying-event and pileup effects beyond subtraction.
  • Transformer framework: Transformers are applied as callable objects, and their additional structure is accessed with transformed_jet.structure_of<MyTransformer>().The structure object has type MyTransformer::StructureType; compatibility can be checked with transformed_jet.has_structure_of<MyTransformer>().
  • Filtering and trimming: Filtering reclusters constituents with a smaller radius and keeps the nfilt hardest subjets, while trimming keeps subjets above a fixed pt fraction.Filtering can optionally subtract a specified background density before selecting kept subjets.
  • Pruning: Pruning reclusters constituents while vetoing soft, large-angle recombinations, discarding the softer pseudojets when the veto conditions are met.Its angular threshold scales as Rcut_factor×2m/pt using the original jet mass and transverse momentum, making default pruning a noise-removing boosted-object tagger.
  • Boosted-object taggers: FastJet includes the fastjet::MassDropTagger as its main two-body tagger and fastjet::JHTopTagger as its main boosted top tagger.JHTopTagger derives from TopTaggerBase, which provides a common framework for top taggers capable of returning a W.

10 Compilation notes

FastJet uses the standard configure, make, make check, and make install procedure, with options documented in INSTALL or available via ./configure --help. CGAL support enables the NlnN kt strategy, N ln N Cambridge/Aachen performance, and N3/2 anti-kt performance, while NlnNCam does not require CGAL.

  • 10 Compilation notes: FastJet compilation and installation use the standard ./configure, make, make check, and make install procedure.Available options are documented in the top-level INSTALL file and can also be listed with ./configure --help.
  • 10 Compilation notes: CGAL support is required to access the NlnN strategy for the kt algorithm.CGAL is enabled at the configure stage with --enable-cgal.
  • 10 Compilation notes: N ln N performance applies to Cambridge/Aachen and N3/2 performance to anti-kt with the CGAL-based strategy.The anti-kt sequence triggers a worst-case scenario for the underlying computational geometry methods.
  • 10 Compilation notes: The NlnNCam strategy does not require CGAL because it uses a simpler computational-geometry structure.This strategy is based on a considerably simpler computational-geometry structure.

A Clustering strategies and performance

FastJet offers multiple clustering strategies that maintain geometrical nearest-neighbour information using different heuristics, tiling, data structures, or Delaunay triangulation. The default Best strategy selects among them, but its performance depends on N, R, algorithm, and event structure, leaving scope for manual tuning and further optimization.

  • Strategy implementations: Clustering strategies factorise energy and geometrical-distance components of the dij measure and dynamically maintain a nearest-neighbour graph.This framework applies equally to any of the relevant algorithms.
  • Strategy implementations: N2Plain uses a nearest-neighbour heuristic, N2Tiled restricts searches through y −φ-cylinder tiling, and N2MinHeapTiled uses an N ln N data structure for nearest-neighbour dij values.NlnN instead uses CGAL’s Delaunay Triangulation to maintain the nearest-neighbour structure.
  • Strategy selection: The default Best option selects the strategy automatically, but the quoted optimal N ranges assume R = 1 and manual choices can be faster in specific N and R regions.The general R dependence can be significant and non-trivial, and NlnNCam timings may depend strongly on additional conditions described in the manual.
  • Performance: Best-strategy timing curves show kinks when native algorithms switch strategies, with occasional imperfections whose impact is generally modest and depends on event structure.The kt algorithm exhibits an example near N = 20 000.
  • Performance: Potential improvements include reducing low-N copying and sorting overheads, using multiple grid sizes for Cambridge/Aachen, and exploiting ghost behavior for anti-kt jet-area calculations.The manual identifies O (1) benefits for Cambridge/Aachen at moderate to large N and for anti-kt when ghost particles dominate N.

B User Info in PseudoJets

FastJet supports attaching extra information to a PseudoJet either through a simple user index or through a derived UserInfoBase object. The latter uses shared ownership so copied PseudoJets share the information and it is deleted automatically when no copies remain.

  • Motivation: A user index can encode simple data such as an input particle’s HepMC barcode, but it is limited when particles need multiple attributes, such as their source event in pileup.The manual motivates richer user information for particles drawn from several HepMC events.
  • Interface: Users can derive a class from PseudoJet::UserInfoBase and attach an instance with set_user_info, retrieving it through user_info_ptr or the typed user_info<L>() accessor.The typed accessor performs the cast and throws an error if the cast fails or no user information has been set.
  • Ownership: Shared ownership lets copied PseudoJets point to the same user information, which is automatically deleted when the PseudoJet and all copies go out of scope.This also handles memory allocated when a Recombiner sets new user information on a recombined PseudoJet.
  • Limitations: User information is absent from ghosts used in clustering with explicit ghosts, so callers should not request it for ghosts.The manual suggests checking ghost status, including with SelectorIsPureGhost().

C Structural information for various kinds of PseudoJet … E.1 External Recombination Schemes

FastJet 3 provides structured access for PseudoJets, a uniform framework for functions acting on jets, and extension points for user-defined recombination schemes. These interfaces expose structure conditionally, standardize callable transformations, and allow custom preprocessing and ownership management.

  • C Structural information for various kinds of PseudoJet: FastJet 3 lets PseudoJets expose constituents or pieces according to whether they originate from clustering or join(...) operations.Table 3 summarizes the results returned by commonly used structural-access methods for different PseudoJet types.
  • C Structural information for various kinds of PseudoJet: Clustering-related structural queries require an associated cluster sequence and generally throw an error when none is available.has_subdmerge() and exclusive_subjets() instead return false in the stated exception cases.
  • C Structural information for various kinds of PseudoJet: Area information is available for jets from ClusterSequenceAreaBase or composites of such jets; otherwise area-related calls report failure or throw an error.has_area() is false without suitable area information, while other area calls use the associated area sequence or composite pieces.
  • C Structural information for various kinds of PseudoJet: PseudoJets store structural information through a shared PseudoJetStructureBase pointer, with derived structures answering queries such as constituents and pieces.Direct access uses structure_ptr(), structure_non_const_ptr(), structure(), and structure_of(), with the latter two casting to derived types.
  • D Functions of a PseudoJet: FunctionOfPseudoJet provides a common interface for transformations returning PseudoJets and calculations returning values associated with jets.Derived classes implement result(...), while operator(...) applies it to one PseudoJet or each element of a vector.
  • D Functions of a PseudoJet: The framework supports passing jet functions as arguments and permits initialization with additional arguments through classes rather than function pointers.Background rescalings derive from FunctionOfPseudoJet<double>, and Transformers derive from FunctionOfPseudoJet<PseudoJet>.
  • E.1 External Recombination Schemes: Users can define external recombination schemes by deriving JetDefinition::Recombiner and implementing description(), recombine(), and, when needed, preprocess().preprocess() can make input jets compatible with scheme requirements, such as being massless.
  • E.1 External Recombination Schemes: A JetDefinition accepts a Recombiner pointer, and unused() can transfer ownership so the JetDefinition deletes the recombiner when no longer needed.JetDefinition::DefaultRecombiner illustrates implementing new recombination classes.

E.2 Implementation of a plugin jet algorithm … E.4 User-defined transformers

FastJet supports extensibility through plugin jet algorithms, user-defined selectors, and transformers. These interfaces let users register clustering histories, implement selection logic, and preserve or extend jet structural information.

  • E.2 Implementation of a plugin jet algorithm: Plugins must define description() and run_clustering(), with the latter performing the algorithm’s clustering and transferring its recombinations to ClusterSequence.The clustering interface records pairwise and beam recombinations through ClusterSequence member functions rather than modifying the existing jets() entries directly.
  • E.2 Implementation of a plugin jet algorithm: Plugins record ij and iB recombinations, while cone algorithms can encode non-pairwise clustering through fictitious recombinations and attach extra information.The dij functions return the index of each newly formed pseudojet, and ClusterSequence::Extras provides access to information such as stable cones.
  • E.2.1 Building new sequential recombination algorithms: FastJet’s NNH class helps new sequential recombination plugins maintain nearest-neighbour information and can yield N2-time clustering in good C/A-like cases.NNH is provided specifically to establish and maintain the closest pair of objects in a dynamic set.
  • E.3 Implementing new selectors: A new selector derives from SelectorWorker; simple implementations overload pass() and description(), while advanced workers may require copy() and further interface-specific methods.Selector is a lightweight object containing a shared pointer to the worker, which performs the selection and manages associated memory through shared ownership.
  • E.4 User-defined transformers: User-defined transformers derive from Transformer and implement result(), description(), and StructureType to produce transformed jets with structural information.Transformer extends FunctionOfPseudoJet<PseudoJet> and supports standard and supplemental structural information for resulting jets.
  • E.4 User-defined transformers: The SimpleFilter example reclusters a jet’s constituents, selects subjets, and joins the selected ones using the subjet definition’s recombiner.This basic implementation provides access to the filtered jet’s pieces through join(...), while the full Filter additionally handles areas, pileup subtraction, and C/A reclustering avoidance.
  • E.4 User-defined transformers: Additional transformer structure can expose rejected subjets by deriving a CompositeJetStructure, storing them during result(), and retrieving them through structure_of<SimpleFilter>().rejected().The selector’s sift operation separates selected and rejected subjets before the returned jet is joined with the user-defined structure.
  • E.4 User-defined transformers: WrappedStructure instead extends arbitrary existing structures by redirecting standard queries and adding new ones, with shared pointers managing their lifetime.Compared with templated join<...>, WrappedStructure is broader, whereas join<...> uses fewer pointer indirections and may be marginally more efficient.

F Error handling … G.3 Backwards compatibility of background estimation facilities

FastJet provides configurable warning and error handling, including suppression, summaries, output redirection, and backtrace control. Across versions, it expands jet-analysis capabilities while preserving selected legacy background-estimation interfaces and behaviors for compatibility.

  • F Error handling: FastJet uses LimitedWarning for warnings and Error for errors, with customization options for redirecting and summarizing their output.Users normally do not need to interact with these classes directly.
  • F Error handling: Warnings are emitted at most 5 times per kind by default, after which output is suppressed while execution continues.LimitedWarning::summary() reports both explicit and suppressed warnings.
  • F Error handling: Errors abort the program, but users can control message and backtrace printing and retrieve the specific message with message().Message printing defaults to true, whereas backtrace printing defaults to false.
  • F Error handling: LimitedWarning and Error output normally goes to std::cerr but can be redirected to a file through set_default_stream().The summary is available only if the program did not abort earlier due to an error.
  • G.1 History: FastJet’s evolution added Cambridge/Aachen clustering, jet areas, background estimation, a new interface, faster strategies, recombination schemes, plugins, and advanced jet-analysis tools.Version 3 also added PseudoJet access to constituents and support for associating extra information with PseudoJets.
  • G.2 Deprecated and removed features: FastJet generally aims to maintain backwards compatibility, but deprecates or removes interfaces when older functionality no longer meets the standards required of the widely used program.Table 4 summarizes deprecated and removed features.
  • G.3 Backwards compatibility of background estimation facilities: Background-estimation facilities from FastJet 2.3 and 2.4 remain available in all FastJet 3.0.x versions through ClusterSequenceAreaBase and legacy RangeDefinition-based interfaces.JetMedianBackgroundEstimator and GridMedianBackgroundEstimator are new to FastJet 3.
  • G.3 Backwards compatibility of background estimation facilities: FastJet 3 changes background-estimation defaults and fixes legacy behavior, while explicit options reproduce earlier area, σ, and ghost-placement results when needed.The transverse 4-vector area is now the default for ρ determination; set_use_area_4vector(false), set_sigma(true), and set_placement(true) restore specified older behaviors.
Loading 1111.6097v1…