FastJet

https://fastjet.fr/repo/doxygen-3.5.0
Admin
FastJet is a C++ library for clustering particles into jets, providing tools for jet analysis...
Tokens:1,100,371
Snippets:9,350
Trust Score:8.7
Update:3 months ago
Show doc for...
Tokens:
Raw
### FastJet Areas Example Program Setup

Source: https://fastjet.fr/repo/doxygen-3.5.0/fastjet__areas_8cc_source.html

This C++ code sets up the FastJet environment for an example program. It includes necessary headers for particle representation, clustering algorithms, and configuration details. It also defines a function to print jets.

```C++
#include "fastjet/PseudoJet.hh"
#include "fastjet/ClusterSequenceArea.hh"
#include "fastjet/ClusterSequencePassiveArea.hh"

// get info on how fastjet was configured
#include "fastjet/config.h"

#ifdef ENABLE_PLUGIN_SISCONE
#include "fastjet/SISConePlugin.hh"
#endif

#include<iostream> // needed for io
#include<sstream> // needed for internal io
#include<vector>

using namespace std;

// a declaration of a function that pretty prints a list of jets
void print_jets (const vector<fastjet::PseudoJet> &);
```

--------------------------------

### Compile and Run FastJet Example

Source: https://fastjet.fr/repo/doxygen-3.5.0/fastjet__example_8cc_source.html

Instructions on how to compile and run the main FastJet example program. This example demonstrates basic usage of the FastJet library for jet clustering.

```bash
make fastjet_example
```

```bash
./fastjet_example < data/single-event.dat
```

--------------------------------

### Main function example

Source: https://fastjet.fr/repo/doxygen-3.5.0/02-jetdef_8cc.html

This is an example program demonstrating the usage of the FastJet library. It includes necessary headers for clustering and input/output operations.

```cpp
#include "fastjet/ClusterSequence.hh"
#include <iostream>
#include <cstdio>

```

```cpp
int main () 
{
  // an example program showing how to use fastjet   
  return 0;
}

```

--------------------------------

### Main Function Example

Source: https://fastjet.fr/repo/doxygen-3.5.0/05-eplus__eminus_8cc.html

This is an example program demonstrating the usage of the FastJet library. It includes necessary headers for clustering and input/output operations.

```cpp
#include "fastjet/ClusterSequence.hh"
#include <iostream>
#include <cstdio>
```

```cpp
int main ()
```

--------------------------------

### Build and Run Examples with Valgrind

Source: https://fastjet.fr/repo/doxygen-3.5.0/test_8py_source.html

Builds C++ example files using g++ and then runs them under Valgrind to check for memory errors. Logs build and Valgrind output to specified files.

```python
print_and_log('Running (rebuilt) examples through valgrind')
os.chdir('example')
fj_args=run_get_output(f'{install_prefix}/bin/fastjet-config --cxxflags --libs --plugins')[0]
valgrind_summary=[]
all_ok = True
for fname in sorted(glob.glob('[01]*.cc')):
 print_and_log (f' source file: {fname}')
 # build
 oname=fname[:-3]
 run_log(f'g++ {fname} {fj_args} -o {oname}', outputlogfile = buildfile)

 # figure out how to run
 tmp=run_get_output(f"grep 'run it with.*[01].*<' {fname} | sed 's/.*://'")[0]

 # run through valgrind
 output = run_get_output(f'valgrind {tmp}')
 log('--------------------------------------------------------------------------------', lgfile = checkfile)
 log(f'output of valgrind {tmp}', lgfile = checkfile)
 for l in output:
 log(f' {l}', lgfile = checkfile)

 # check if we see sth off
 #
 # heap usage: expect 
 # total heap usage: 1,452 allocs, 1,452 frees
 # look at difference between allocs and frees
 found_info=False
 ok_so_far = True
 log_str = f' {oname:25}: '
 for l in output:
 if l.find('total heap usage:') >= 0:
 found_info=True
 tokens=l.split()
 print(tokens)
 if tokens[4] != tokens[6]:
 log_str += f'heap problem ({tokens[4]} {tokens[5]} {tokens[6]} {tokens[7]})'
 ok_so_far = False
 break
 if not found_info:
 ok_so_far=False
 log_str += 'problem (heap info not found)'

 # memory leaks string
 if ok_so_far: # we expect to see 'All heap blocks were freed -- no leaks are possible'
 found_info=False
 for l in output:
 if l.find('All heap blocks were freed -- no leaks are possible') >= 0:
 found_info=True
 break
 if not found_info:
 ok_so_far=False
 log_str += 'leak info not found'

 # check the erorr summary
 found_info=False
```

--------------------------------

### Build and run FastJet example program

Source: https://fastjet.fr/repo/doxygen-3.5.0/INSTALL_source.html

Compile and execute the example program provided with FastJet. This uses the static makefile and redirects input from a data file.

```bash
make -f makefile.static fastjet_example
./fastjet_example < data/single-event.dat
```

--------------------------------

### start

Source: https://fastjet.fr/repo/doxygen-3.5.0/functions_func_s.html

Starts an operation for various NNBase related classes.

```APIDOC
## start

### Description
Starts an operation.

### Method
Not specified.

### Endpoint
Not applicable (function call).

### Parameters
None explicitly defined in the provided text.

### Response
Returns the object itself or a status indicator. Applicable to fastjet::NNBase< I >, fastjet::NNFJN2Plain< BJ, I >, fastjet::NNFJN2Tiled< BJ, I >, fastjet::NNH< BJ, I >.
```

--------------------------------

### Basic Jet Clustering Example

Source: https://fastjet.fr/repo/doxygen-3.5.0/12-boosted__higgs_8cc_source.html

Demonstrates the fundamental usage of FastJet for clustering jets. This is a starting point for most jet analysis tasks.

```C++
// This is a placeholder for a basic jet clustering example.
// The actual code would involve setting up a JetDefinition and ClusterSequence,
// then processing a list of input particles (PseudoJets).
// Example structure:
// 
// #include "fastjet/ClusterSequence.hh"
// #include "fastjet/JetDefinition.hh"
// #include "fastjet/PseudoJet.hh"
// 
// int main() {
//   // Define the jet algorithm and parameters
//   fastjet::JetDefinition jet_def(fastjet::cambridge_algorithm, 0.4);
// 
//   // Create a ClusterSequence
//   fastjet::ClusterSequence cs(input_particles, jet_def);
// 
//   // Get the clustered jets
//   std::vector<fastjet::PseudoJet> jets = cs.inclusive_jets(0.0);
// 
//   // Process or print the jets...
//   return 0;
// }
```

--------------------------------

### FastJet Basic Example Program

Source: https://fastjet.fr/repo/doxygen-3.5.0/Example01.html

Illustrates the usage of basic FastJet classes: PseudoJet, JetDefinition, and ClusterSequence. Run this example with './01-basic < data/single-event.dat'.

```c++
#include <fastjet/PseudoJet.hh>
#include <fastjet/JetDefinition.hh>
#include <fastjet/ClusterSequence.hh>
#include <iostream>
#include <vector>

using namespace std;
using namespace fastjet;

int main(int argc, char **argv) {

  // setup the jet definition
  // use fjcore::cambridge for Cambridge jets, fjcore::antikt for anti-kt jets etc.
  JetDefinition jetdef(fjcore::cambridge, 15.0);

  // create an empty list of particles
  vector<PseudoJet> particles;

  // add some particles to the list
  // arguments are E, px, py, pz
  particles.push_back(PseudoJet(10, 1, 0, 0));
  particles.push_back(PseudoJet(5, -1, 0, 0));
  particles.push_back(PseudoJet(7, 0, 1, 0));
  particles.push_back(PseudoJet(3, 0, -1, 0));

  // create a ClusterSequence
  ClusterSequence cs(particles, jetdef);

  // get the jets
  vector<PseudoJet> jets = cs.inclusive_jets(0.0);

  // print the jets
  cout << "Found " << jets.size() << " jets:\n";
  for (const auto &jet : jets) {
    cout << "  " << jet.E() << "  " << jet.px() << "  " << jet.py() << "  " << jet.pz() << "\n";
  }

  return 0;
}
```

--------------------------------

### main()

Source: https://fastjet.fr/repo/doxygen-3.5.0/globals_func.html

The main function serves as the entry point for the FastJet examples. It is documented across multiple source files, indicating its central role in various examples.

```APIDOC
## main()

### Description
The main function is the entry point for FastJet examples. It is referenced in several example files, highlighting its fundamental role in demonstrating FastJet functionalities.

### Functions
- main()

### Files
- 01-basic.cc
- 02-jetdef.cc
- 04-constituents.cc
- 05-eplus_eminus.cc
- 06-area.cc
- 11-filter.cc
- 14-groomers.cc
- fastjet_example.cc
```

--------------------------------

### FastJet Main Example Program

Source: https://fastjet.fr/repo/doxygen-3.5.0/fastjet__example_8cc.html

An example program demonstrating the usage of the FastJet library for jet clustering and analysis. It includes necessary headers for PseudoJet and ClusterSequence.

```C++
#include "fastjet/PseudoJet.hh"
#include "fastjet/ClusterSequence.hh"
#include <iostream>
#include <sstream>
#include <vector>
#include <cstdio>

int main() {
    // Example usage of FastJet
    return 0;
}
```

--------------------------------

### FastJet Example Program Structure

Source: https://fastjet.fr/repo/doxygen-3.5.0/fastjet__example_8cc_source.html

The main function of the FastJet example program, including necessary includes and the initial setup for reading input particles.

```c++
#include "fastjet/PseudoJet.hh"
#include "fastjet/ClusterSequence.hh"
#include<iostream> // needed for io
#include<sstream> // needed for internal io
#include<vector>
#include <cstdio>

using namespace std;

// a declaration of a function that pretty prints a list of jets
void print_jets (const vector<fastjet::PseudoJet> &);

/// an example program showing how to use fastjet
int main () {

 vector<fastjet::PseudoJet> input_particles;

 // Read in input particles

```

--------------------------------

### Build and install FastJet using static makefile

Source: https://fastjet.fr/repo/doxygen-3.5.0/INSTALL_source.html

Commands to build and install FastJet using the older, non-autotools static makefile. Ensure you specify '-f makefile.static' to use these makefiles.

```bash
make -f makefile.static
make -f makefile.static install
```

--------------------------------

### FastJet Example: Accessing Subjets

Source: https://fastjet.fr/repo/doxygen-3.5.0/Example10.html

This C++ example demonstrates how to access subjets within FastJet. It is intended to be run with sample data.

```cpp
#include <fastjet/ClusterSequence.hh>
#include <fastjet/PseudoJet.hh>
#include <iostream>
#include <vector>

int main() {
    // Define a jet algorithm (e.g., anti-kT with R=0.4)
    fastjet::JetDefinition jet_def(fastjet::antikt_algorithm, 0.4);

    // Create a ClusterSequence object
    fastjet::ClusterSequence cs(input_particles, jet_def);

    // Get the list of jets
    std::vector<fastjet.PseudoJet> jets = cs.inclusive_jets(0.0);

    // Iterate through the jets and access their subjets
    for (const auto& jet : jets) {
        std::cout << "Jet pt: " << jet.pt() << std::endl;
        std::cout << "  Number of subjets: " << jet.number_of_constituents() << std::endl;

        // Accessing subjets (constituents of the jet)
        for (const auto& subjet : jet.constituents()) {
            std::cout << "    Subjet pt: " << subjet.pt() << std::endl;
        }
    }

    return 0;
}

```

--------------------------------

### Main Function for Boosted Higgs Example

Source: https://fastjet.fr/repo/doxygen-3.5.0/12-boosted__higgs_8cc.html

The main entry point for the boosted Higgs example. It sets up jet clustering, applies mass drop tagging, and filters jets. This function demonstrates a typical analysis workflow.

```C++
int main() {
    // set up the jet definition
    JetDefinition jet_def(fastjet::cambridge_algorithm, 1.5);
    // set up the mass drop tagger
    MassDropTagger md_tagger(0.075, 0.0, 1);
    // set up the filter
    Filter filter(jet_def, md_tagger);
    // create a list of particles
    vector<PseudoJet> particles;
    // ... fill particles ...
    // run the filter
    vector<PseudoJet> filtered_jets = filter(particles);
    // print the filtered jets
    for (const auto &jet : filtered_jets) {
        cout << jet << endl;
    }
    return 0;
}
```

--------------------------------

### Run Boosted Top Subjet ID Example

Source: https://fastjet.fr/repo/doxygen-3.5.0/Example13.html

This example demonstrates how to run a boosted top subjet identification analysis using the Johns Hopkins top tagger. It requires input data from 'data/boosted_top_event.dat'.

```bash
./13-boosted_top < data/boosted_top_event.dat
```

--------------------------------

### Boosted Top Tagger Example

Source: https://fastjet.fr/repo/doxygen-3.5.0/13-boosted__top_8cc_source.html

Illustrates a boosted top subjet ID analysis using the Johns Hopkins top tagger. Run this example with: ./13-boosted_top < data/boosted_top_event.dat.

```c++
#include <iostream>
#include <sstream>
#include <iomanip>
#include <cmath>

#include <fastjet/ClusterSequence.hh>
#include <fastjet/Selector.hh>
#include <fastjet/tools/JHTopTagger.hh>

using namespace std;
using namespace fastjet;

//----------------------------------------------------------------------
// forward declaration for printing out info about a jet
//----------------------------------------------------------------------
ostream & operator<<(ostream &, const PseudoJet &);

//----------------------------------------------------------------------
// core of the program
//----------------------------------------------------------------------
int main(){

 vector<PseudoJet> particles;

 // read in data in format px py pz E b-tag [last of these is optional]
 // lines starting with "#" are considered as comments and discarded
 //----------------------------------------------------------
 string line;
 while (getline(cin,line)) {
 if (line.substr(0,1) == "#") {continue;}

```

--------------------------------

### Get Circulator to Tree Element

Source: https://fastjet.fr/repo/doxygen-3.5.0/SearchTree_8hh_source.html

Returns a circulator object pointing to an arbitrary element within the SearchTree. This is useful for starting traversals when the specific starting point is not critical.

```cpp
template<class T> typename SearchTree<T>::circulator SearchTree<T>::somewhere() {
return circulator(_top_node);
}
```

--------------------------------

### Initialize and Use JHTopTagger

Source: https://fastjet.fr/repo/doxygen-3.5.0/JHTopTagger_8hh_source.html

Demonstrates how to initialize a JHTopTagger with custom parameters and apply it to a jet. It also shows how to set mass selectors for the top and W bosons and how to access the tagged top candidate and its substructure.

```cpp
double delta_p = 0.10; // subjets must carry at least this fraction of the original jet's p_t
double delta_r = 0.19; // subjets must be separated by at least this Manhattan distance
double cos_theta_W_max = 0.7; // the maximal allowed value of the W helicity angle
JHTopTagger top_tagger(delta_p, delta_r, cos_theta_W_max);
// indicate the acceptable range of top, W masses (default: no limits)
top_tagger.set_top_selector(SelectorMassRange(150,200));
top_tagger.set_W_selector (SelectorMassRange( 65, 95));
// now try and tag a jet
PseudoJet top_candidate = top_tagger(jet); // jet should come from a Cambridge/Aachen clustering
if (top_candidate != 0) { // successful tagging
double top_mass = top_candidate.m();
double W_mass = top_candidate.structure_of<JHTopTagger>().W().m();
}
```

--------------------------------

### Initialize Tiles Method

Source: https://fastjet.fr/repo/doxygen-3.5.0/LazyTiling9SeparateGhosts_8cc_source.html

Sets up the tiling grid for the LazyTiling9SeparateGhosts algorithm. This involves determining tile sizes in eta and phi, allocating memory for tiles, and establishing neighborhood relationships between tiles, with precautions for edge cases.

```c++
void LazyTiling9SeparateGhosts::_initialise_tiles() {

 // first decide tile sizes (with a lower bound to avoid huge memory use with
 // very small R)
 double default_size = max(0.1,_Rparam);
 _tile_size_eta = default_size;
 // it makes no sense to go below 3 tiles in phi -- 3 tiles is
 // sufficient to make sure all pair-wise combinations up to pi in
 // phi are possible
```

--------------------------------

### Get Circulator to an Arbitrary Tree Element

Source: https://fastjet.fr/repo/doxygen-3.5.0/SearchTree_8hh_source.html

Returns a circulator to an arbitrary position within the tree. The exact starting point is not guaranteed.

```cpp
const_circulator somewhere() const;
```

```cpp
circulator somewhere();
```

--------------------------------

### Get Last Seed

Source: https://fastjet.fr/repo/doxygen-3.5.0/GhostedAreaSpec_8hh_source.html

Allows the user to retrieve the seed that was used at the start of the last ghost generation process. Useful for debugging or re-running specific ghost configurations.

```cpp
void get_last_seed(std::vector< int > &__iseed) const
```

--------------------------------

### Initialize Tiles Configuration

Source: https://fastjet.fr/repo/doxygen-3.5.0/LazyTiling9Alt_8cc_source.html

Sets up the tiling grid by determining tile sizes in eta and phi, ensuring minimum tile counts and sizes to avoid excessive memory usage and cover all phi combinations.

```cpp
void LazyTiling9Alt::_initialise_tiles() {

 // first decide tile sizes (with a lower bound to avoid huge memory use with
 // very small R)
 double default_size = max(0.1,_Rparam);
 _tile_size_eta = default_size;
 // it makes no sense to go below 3 tiles in phi -- 3 tiles is
 // sufficient to make sure all pair-wise combinations up to pi in
 // phi are possible
 _n_tiles_phi = max(3,int(floor(twopi/default_size)));
 _tile_size_phi = twopi / _n_tiles_phi; // >= _Rparam and fits in 2pi

 // always include zero rapidity in the tiling region
 _tiles_eta_min = 0.0;
 _tiles_eta_max = 0.0;
 // but go no further than following
 const double maxrap = 7.0;

}

```

--------------------------------

### Retrieving Last Used Seed

Source: https://fastjet.fr/repo/doxygen-3.5.0/GhostedAreaSpec_8hh_source.html

Gets the seed that was used at the start of the last ghost generation. Issues a warning if repeat > 1, as fixed seeds are not sensible in that case.

```C++
void get_last_seed(std::vector<int> & __iseed) const {
if (_repeat > 1) _warn_fixed_last_seeds_nrepeat_gt_1
.warn("Using fixed seeds (or accessing last used seeds) not sensible with repeat>1");
__iseed = _last_used_seed;
}
```

--------------------------------

### Get Const Circulator to Somewhere in Tree

Source: https://fastjet.fr/repo/doxygen-3.5.0/SearchTree_8hh_source.html

Returns a const_circulator to an unspecified location within the tree. This is useful when a starting point for read-only traversal is needed but the exact position doesn't matter.

```cpp
const_circulator somewhere() const
return a circulator to some place in the tree (with a circulator you don't care where....)
```

--------------------------------

### Initialize and Set Up Tiles

Source: https://fastjet.fr/repo/doxygen-3.5.0/LazyTiling9SeparateGhosts_8cc_source.html

This code block initializes the tiling parameters and sets up the grid of tiles. It calculates the number and size of tiles based on jet rapidities and then iterates through each tile to set up its cross-referencing pointers to neighboring tiles.

```cpp
// always include zero rapidity in the tiling region
        _tiles_eta_min = 0.0;
        _tiles_eta_max = 0.0;
        // but go no further than following
        const double maxrap = 7.0;

        // and find out how much further one should go
        for(unsigned int i = 0; i < _jets.size(); i++) {
        double eta = _jets[i].rap();
        // first check if eta is in range -- to avoid taking into account
        // very spurious rapidities due to particles with near-zero kt.
        if (abs(eta) < maxrap) {
        if (eta < _tiles_eta_min) {_tiles_eta_min = eta;}
        if (eta > _tiles_eta_max) {_tiles_eta_max = eta;}
        }
        }

        // now adjust the values
        _tiles_ieta_min = int(floor(_tiles_eta_min/_tile_size_eta));
        _tiles_ieta_max = int(floor( _tiles_eta_max/_tile_size_eta));
        _tiles_eta_min = _tiles_ieta_min * _tile_size_eta;
        _tiles_eta_max = _tiles_ieta_max * _tile_size_eta;

        _tile_half_size_eta = _tile_size_eta * 0.5;
        _tile_half_size_phi = _tile_size_phi * 0.5;

        // allocate the tiles
        _tiles.resize((_tiles_ieta_max-_tiles_ieta_min+1)*_n_tiles_phi);

        // now set up the cross-referencing between tiles
        for (int ieta = _tiles_ieta_min; ieta <= _tiles_ieta_max; ieta++) {
        for (int iphi = 0; iphi < _n_tiles_phi; iphi++) {
        Tile3 * tile = & _tiles[_tile_index(ieta,iphi)];
        // no jets in this tile yet
        tile->head = NULL; // first element of tiles points to itself
        tile->ghost_head = NULL; // first element of tiles points to itself
        tile->begin_tiles[0] = tile;
        Tile3 ** pptile = & (tile->begin_tiles[0]);
        pptile++;
        //
        // set up L's in column to the left of X
        tile->surrounding_tiles = pptile;
        if (ieta > _tiles_ieta_min) {
        // with the itile subroutine, we can safely run tiles from
        // idphi=-1 to idphi=+1, because it takes care of
        // negative and positive boundaries
        for (int idphi = -1; idphi <=+1; idphi++) {
        *pptile = & _tiles[_tile_index(ieta-1,iphi+idphi)];
        pptile++;
        }
        } else {
        // if we are at the minimum eta boundary, we need to wrap around
        // to the maximum eta boundary for the surrounding tiles
        for (int idphi = -1; idphi <=+1; idphi++) {
        *pptile = & _tiles[_tile_index(_tiles_ieta_max,iphi+idphi)];
        pptile++;
        }
        }
        // now set up last L (below X)
        *pptile = & _tiles[_tile_index(ieta,iphi-1)];
        pptile++;
        // set up first R (above X)
        tile->RH_tiles = pptile;
        *pptile = & _tiles[_tile_index(ieta,iphi+1)];
        pptile++;
        // set up remaining R's, to the right of X
        if (ieta < _tiles_ieta_max) {
        for (int idphi = -1; idphi <= +1; idphi++) {
        *pptile = & _tiles[_tile_index(ieta+1,iphi+idphi)];
        pptile++;
        }
        } else {
        // if we are at the maximum eta boundary, we need to wrap around
        // to the minimum eta boundary for the surrounding tiles
        for (int idphi = -1; idphi <= +1; idphi++) {
        *pptile = & _tiles[_tile_index(_tiles_ieta_min,iphi+idphi)];
        pptile++;
        }
        }
        // now put semaphore for end tile
        tile->end_tiles = pptile;
        // finally make sure tiles are untagged
        tile->tagged = false;
        // and ensure max distance is sensibly initialised
        tile->max_NN_dist = 0;
        // and also position of centre of tile
        tile->eta_centre = (ieta+0.5)*_tile_size_eta;
        tile->phi_centre = (iphi+0.5)*_tile_size_phi;
        }
        }

```

--------------------------------

### somewhere

Source: https://fastjet.fr/repo/doxygen-3.5.0/SearchTree_8hh_source.html

Returns a circulator to an arbitrary position within the search tree. This is useful for starting traversals when the specific starting point is not important.

```APIDOC
## somewhere

### Description
Returns a circulator to an arbitrary position within the search tree. This is useful for starting traversals when the specific starting point is not important.

### Method
circulator

### Endpoint
N/A (Method within a class)

### Parameters
None

### Request Example
N/A

### Response
#### Success Response
- **circulator** (fastjet::SearchTree::circulator) - A circulator object pointing to an element in the tree.

#### Response Example
N/A
```

--------------------------------

### initialise

Source: https://fastjet.fr/repo/doxygen-3.5.0/classfastjet_1_1MinHeap.html

Initializes the MinHeap with a new set of values.

```APIDOC
## void initialise(const std::vector<double>& values)

### Description
Initializes the heap with the supplied values.

### Parameters
#### Path Parameters
- None

#### Query Parameters
- None

#### Request Body
- **values** (const std::vector<double>&) - The values to initialize the heap with.

### Method Signature
`void fastjet::MinHeap::initialise(const std::vector<double>& values)`
```

--------------------------------

### Include Headers for Basic Example

Source: https://fastjet.fr/repo/doxygen-3.5.0/01-basic_8cc.html

Includes necessary headers for using FastJet's ClusterSequence and standard I/O operations.

```c++
#include "fastjet/ClusterSequence.hh"
#include <iostream>
#include <cstdio>
```

--------------------------------

### FastJet Plugin Example Program

Source: https://fastjet.fr/repo/doxygen-3.5.0/Example03.html

Illustrates the usage of FastJet plugins, specifically the SISCone plugin. The code needs to be linked against the libfastjetplugins library. Run with: ./03-plugin < data/single-event.dat

```cpp
// This is a placeholder for the actual C++ code from 03-plugin.cc
// The source text only provided a description and a command to run it,
// not the actual code content. Therefore, this snippet cannot be populated.
// Please provide the actual C++ source code for 03-plugin.cc to include it here.
```

--------------------------------

### Setup Tiles for Clustering

Source: https://fastjet.fr/repo/doxygen-3.5.0/ClusterSequence__TiledN2_8cc_source.html

Initializes the tiling system for jet clustering. This involves determining the eta range, allocating tile structures, and setting up cross-referencing for neighboring tiles.

```C++
//----------------------------------------------------------------------
/// Set up the tiles:
/// - decide the range in eta
/// - allocate the tiles
/// - set up the cross-referencing info between tiles
///
/// The neighbourhood of a tile is set up as follows
///
/// LRR
/// LXR
/// LLR
///
/// such that tiles is an array containing XLLLLRRRR with pointers
/// | \ RH_tiles
/// \ surrounding_tiles
///
/// with appropriate precautions when close to the edge of the tiled
/// region.
///
```

--------------------------------

### Initialize and Use SISCone Plugin for Jet Clustering

Source: https://fastjet.fr/repo/doxygen-3.5.0/03-plugin_8cc_source.html

This snippet shows how to create input particles, define a jet clustering algorithm using the SISCone plugin with specified parameters, run the clustering, and retrieve sorted inclusive jets.

```cpp
#include <fastjet/ClusterSequence.hh>
#include <fastjet/SISConePlugin.hh>
#include <fastjet/JetDefinition.hh>
#include <fastjet/PseudoJet.hh>
#include <vector>
#include <iostream>
#include <cstdio>

using namespace std;

int main() {
    // Example input particles (replace with actual data)
    vector<fastjet::PseudoJet> input_particles;
    // Assume input_particles are populated here, e.g.:
    // input_particles.push_back(fastjet::PseudoJet(px, py, pz, E));

    // Create a jet definition from a plugin.
    // We will use the SISCone plugin here. Its (mandatory) parameters
    // are a cone radius and an overlap threshold, plus other optional
    // parameters.
    double cone_radius = 0.7;
    double overlap_threshold = 0.75;
    fastjet::SISConePlugin siscone(cone_radius, overlap_threshold);
    fastjet::JetDefinition jet_def(&siscone);

    // Run the jet clustering with the above jet definition
    fastjet::ClusterSequence clust_seq(input_particles, jet_def);

    // Get the resulting jets ordered in pt
    double ptmin = 5.0;
    vector<fastjet::PseudoJet> inclusive_jets = sorted_by_pt(clust_seq.inclusive_jets(ptmin));

    // Tell the user what was done
    // - the description of the algorithm used
    // - extract the inclusive jets with pt > 5 GeV
    // show the output as 
    // {index, rap, phi, pt}
    cout << "Ran " << jet_def.description() << endl;

    // label the columns
    printf("%5s %15s %15s %15s\n","jet #", "rapidity", "phi", "pt");

    // print out the details for each jet
    for (unsigned int i = 0; i < inclusive_jets.size(); i++) {
        printf("%5u %15.8f %15.8f %15.8f\n",
               i, inclusive_jets[i].rap(), inclusive_jets[i].phi(),
               inclusive_jets[i].perp());
    }

    return 0;
}

```

--------------------------------

### FastJet Subtraction Example Program

Source: https://fastjet.fr/repo/doxygen-3.5.0/Example07.html

This C++ program demonstrates a subtraction example using FastJet. It is intended to be run with specific input data.

```cpp
#include <fastjet/ClusterSequence.hh>
#include <fastjet/PseudoJet.hh>

#include <iostream>
#include <vector>

int main(int argc, char **argv) {
  // all inputs are in GeV and GeV/c
  double R = 0.7;
  fastjet::Strategy strategy = fastjet::Best;
  fastjet::RecombinationScheme recombination_scheme = fastjet::E_scheme;
  fastjet::JetAlgorithm algorithm = fastjet::antikt_algorithm;

  fastjet::JetDefinition jet_def(algorithm, R, recombination_scheme, strategy);

  std::vector<fastjet::PseudoJet> parts;
  double E, px, py, pz;
  while (std::cin >> E >> px >> py >> pz) {
    parts.push_back(fastjet::PseudoJet(px, py, pz, E));
  }

  fastjet::ClusterSequence cs(parts, jet_def);
  std::vector<fastjet::PseudoJet> jets = cs.inclusive_jets(10.0); // get the jets

  std::cout << "\nFound " << jets.count() << " jets:\n";
  for (const auto &jet : jets) {
    std::cout << "  " << jet.perp() << "\n";
  }

  // subtract the jets from the event
  std::vector<fastjet::PseudoJet> remaining_parts = cs.exclusive_jets(1);
  std::cout << "\nRemaining particles after subtraction:\n";
  for (const auto &part : remaining_parts) {
    std::cout << "  " << part.perp() << "\n";
  }

  return 0;
}

```

--------------------------------

### Set Up Background Estimator

Source: https://fastjet.fr/repo/doxygen-3.5.0/07-subtraction_8cc_source.html

Configures a JetMedianBackgroundEstimator using the kt algorithm with R=0.4, explicit ghosts, and a selector to exclude the two hardest jets from the background estimation.

```C++
JetDefinition jet_def_bkgd(kt_algorithm, 0.4);
AreaDefinition area_def_bkgd(active_area_explicit_ghosts, 
GhostedAreaSpec(ghost_maxrap));
Selector selector = SelectorAbsRapMax(4.5) * (!SelectorNHardest(2));
JetMedianBackgroundEstimator bkgd_estimator(selector, jet_def_bkgd, area_def_bkgd);
```

--------------------------------

### SharedPtr Get Pointer Function

Source: https://fastjet.fr/repo/doxygen-3.5.0/SharedPtr_8hh_source.html

A free function to retrieve the raw pointer managed by a SharedPtr. Provides an alternative to the member get() method.

```cpp
template<class T>
inline T* get_pointer(SharedPtr<T> const & t){
return t.get();
}
```

--------------------------------

### FastJet Basic Jet Definition Example

Source: https://fastjet.fr/repo/doxygen-3.5.0/Example02.html

Illustrates how to change the jet definition used for clustering in FastJet. This example requires input data from 'data/single-event.dat'.

```cpp
#include <fastjet/ClusterSequence.hh>
#include <fastjet/PseudoJet.hh>
#include <iostream>
#include <vector>

int main(int argc, char **argv) {
  // --- create a jet definition
  // use fjcore::cambridge for Cambridge jets, fjcore::antikt for anti-kt jets
  // fjcore::cambridge is the default if no argument is given
  fastjet::JetDefinition fj(fastjet::cambridge, 1.0);

  // --- create a list of jets
  std::vector<fastjet::PseudoJet> jets;
  // fill the list of jets with some data
  // for example, read from standard input
  double E, px, py, pz;
  while (std::cin >> E >> px >> py >> pz) {
    jets.push_back(fastjet::PseudoJet(px, py, pz, E));
  }

  // --- run the clustering algorithm
  fastjet::ClusterSequence cs(jets, fj);

  // --- get the clustered jets
  std::vector<fastjet::PseudoJet> sorted_jets = cs.sorted_jets();

  // --- print the jets
  std::cout << "# Found " << sorted_jets.size() << " jets:\n";
  for (const auto &jet : sorted_jets) {
    std::cout << "  " << jet.pt() << " \t" << jet.eta() << " \t" << jet.phi() << " \t" << jet.m() << "\n";
  }

  return 0;
}
```

--------------------------------

### Tile Initialization Logic

Source: https://fastjet.fr/repo/doxygen-3.5.0/LazyTiling9_8cc_source.html

Sets up the tiling structure by determining tile sizes in eta and the number of tiles in phi. It ensures a minimum tile size and a minimum number of tiles in phi to cover all pairwise combinations.

```C++
// first decide tile sizes (with a lower bound to avoid huge memory use with
// very small R)
 double default_size = max(0.1,_Rparam);
 _tile_size_eta = default_size;
 // it makes no sense to go below 3 tiles in phi -- 3 tiles is
 // sufficient to make sure all pair-wise combinations up to pi in
 // phi are possible
 _n_tiles_phi = max(3,int(floor(twopi/default_size)));

```

--------------------------------

### Configure D0RunIpre96Cone Plugin

Source: https://fastjet.fr/repo/doxygen-3.5.0/fastjet__timing__plugins_8cc_source.html

Sets up the D0RunIpre96ConePlugin, an older cone algorithm from the D0 experiment. It requires R, seed threshold, and overlap threshold.

```cpp
jet_defs.push_back( JetDefinition(new D0RunIpre96ConePlugin(ktR, seed_threshold, overlap_threshold)));
```

--------------------------------

### PXCONE Initialization and Parameter Output

Source: https://fastjet.fr/repo/doxygen-3.5.0/pxcone_8f_source.html

Initializes internal variables and prints welcome messages and jet-finder parameters if they have changed since the last call. This snippet also includes conditional output for a private change related to Rsep.

```Fortran
      IF(ncall.LE.0) THEN
 rold = 0.
 epsold = 0.
 ovold = 0.
 ENDIF
 ncall = ncall + 1

 *** Print welcome and Jetfinder parameters
 IF((coner.NE.rold .OR. epslon.NE.epsold .OR. ovlim.NE.ovold)
 + .AND. nprint.LE.10) THEN
 WRITE (6,*) 
 WRITE (6,*) ' *********** PXCONE: Cone Jet-finder ***********'
 WRITE (6,*) ' Written by Luis Del Pozo of OPAL'
 WRITE (6,*) ' Modified for eta-phi by Mike Seymour'
 WRITE (6,*) ' Includes bug fixes by Wobisch, Salam'
 WRITE(6,1000)' Cone Size R = ',coner,' Radians'
 WRITE(6,1001)' Min Jet energy Epsilon = ',epslon,' GeV'
 WRITE(6,1002)' Overlap fraction parameter = ',ovlim
 WRITE (6,*) ' PXCONE is not a supported product and is'
 WRITE (6,*) ' is provided for comparative purposes only'
 WRITE (6,*) ' ***********************************************'
 cMWobisch
 IF (rsep .lt. 1.999) THEN
 WRITE(6,*) ' '
 WRITE (6,*) ' ******************************************'
 WRITE (6,*) ' ******************************************'
 WRITE(6,*) ' M Wobisch: private change !!!!!!!!!!!! '
 WRITE(6,*) ' Rsep is set to ',rsep
 WRITE(6,*) ' this is ONLY meaningful in a NLO calculation'
 WRITE(6,*) ' ------------------------ '
 WRITE(6,*) ' please check what you''re doing!!'
 WRITE(6,*) ' or ask: Markus.Wobisch@desy.de --'
 WRITE (6,*) ' ******************************************'
 WRITE (6,*) ' ******************************************'
 WRITE (6,*) ' ******************************************'
 WRITE(6,*) ' '
 WRITE(6,*) ' '
 ENDIF
 cMWobisch

 WRITE (6,*) 
1000 FORMAT(a18,f5.2,a10)
1001 FORMAT(a29,f5.2,a5)
1002 FORMAT(a33,f5.2)
 nprint = nprint + 1
 rold=coner
 epsold=epslon
 ovold=ovlim
 ENDIF
```

--------------------------------

### Deprecated operator() for Pointer Access

Source: https://fastjet.fr/repo/doxygen-3.5.0/SharedPtr_8hh_source.html

Provides access to the raw pointer, but is deprecated in favor of the get() method. Use with caution and prefer get() for modern code.

```cpp
FASTJET_DEPRECATED_MSG("Use SharedPtr<T>::get() instead",
T* operator ()() const){
if (_ptr==NULL) return NULL;
return _ptr->get(); // automatically returns NULL when out-of-scope
}

```

--------------------------------

### start()

Source: https://fastjet.fr/repo/doxygen-3.5.0/classfastjet_1_1NNFJN2Plain.html

Initializes or re-initializes the NNFJN2Plain object with a new list of particles (PseudoJets). This method is part of the NNBase interface.

```APIDOC
## start()

### Description
Initialises the NNFJN2Plain object from a given list of particles. This method is a virtual function inherited from `fastjet::NNBase< I >`.

### Signature
```cpp
template<class BJ , class I >
void fastjet::NNFJN2Plain< BJ, I >::start(const std::vector< PseudoJet > & _jets_)
```

### Parameters
* `_jets_` (const std::vector< PseudoJet > &) - The list of particles (PseudoJets) to initialize with.
```

--------------------------------

### NNH::start Method Implementation

Source: https://fastjet.fr/repo/doxygen-3.5.0/NNH_8hh_source.html

Initializes the NNH structure with a vector of PseudoJets. It allocates memory for jets, initializes basic jet information, and computes initial nearest neighbor distances.

```cpp
template<class BJ, class I> void NNH<BJ,I>::start(const std::vector<PseudoJet> & jets) {
 n = jets.size();
 briefjets = new NNBJ[n];
 where_is.resize(2*n);

 NNBJ * jetA = briefjets;

 // initialise the basic jet info 
 for (int i = 0; i< n; i++) {
 //jetA->init(jets[i], i);
 this->init_jet(jetA, jets[i], i);
 where_is[i] = jetA;
 jetA++; // move on to next entry of briefjets
 }
 tail = jetA; // a semaphore for the end of briefjets
 head = briefjets; // a nicer way of naming start

 // now initialise the NN distances: jetA will run from 1..n-1; and
 // jetB from 0..jetA-1
 for (jetA = head + 1; jetA != tail; jetA++) {
 // set NN info for jetA based on jets running from head..jetA-1,
 // checking in the process whether jetA itself is an undiscovered
 // NN of one of those jets.
 set_NN_crosscheck(jetA, head, jetA);
 }
 //std::cout << "OOOO " << briefjets[1].NN_dist << " " << briefjets[1].NN - briefjets << std::endl;
}
```

--------------------------------

### Getting and Setting User Index

Source: https://fastjet.fr/repo/doxygen-3.5.0/PseudoJet_8hh_source.html

Provides functions to get and set an integer user index associated with a PseudoJet. This index can be used to store simple identifying information.

```C++
inline int user_index() const {return _user_index;}
inline void set_user_index(const int index) {_user_index = index;}
```

--------------------------------

### Include Headers for Groomers Example

Source: https://fastjet.fr/repo/doxygen-3.5.0/14-groomers_8cc.html

Includes necessary headers for using PseudoJet, ClusterSequence, Selector, Filter, and Pruner in FastJet. Also includes iostream and cstdio for standard I/O and C-style I/O respectively.

```c++
#include <fastjet/PseudoJet.hh>
#include <fastjet/ClusterSequence.hh>
#include <fastjet/Selector.hh>
#include <iostream>
#include "fastjet/tools/Filter.hh"
#include "fastjet/tools/Pruner.hh"
#include <cstdio>
```

--------------------------------

### Trimming Usage Example

Source: https://fastjet.fr/repo/doxygen-3.5.0/Filter_8hh_source.html

Illustrates how to use the Filter class for trimming jets. This example selects all subjets that carry at least 3% of the original jet's transverse momentum.

```C++
#include "fastjet/tools/Filter.hh"
#include "fastjet/JetDefinition.hh"
#include "fastjet/Selector.hh"

// ... inside a function or method ...

// Define the trimming parameters: Use a jet definition (e.g., anti-kt with R=0.4)
// and select subjets with at least 3% of the original jet's pt.
fastjet::JetDefinition jet_def(fastjet::antikt_algorithm, 0.4);
fastjet::Selector selector = fastjet::SelectorPtFractionMin(0.03);

// Create a Filter object for trimming
fastjet::Filter filter(jet_def, selector);

// Apply the filter to an original jet (assuming 'original_jet' is a PseudoJet object)
// PseudoJet trimmed_jet = filter(original_jet);

```

--------------------------------

### SharedPtr get() Method

Source: https://fastjet.fr/repo/doxygen-3.5.0/SharedPtr_8hh_source.html

Returns the raw pointer to the managed object. It checks for null pointers and returns NULL if the SharedPtr is empty. This is the recommended way to get the underlying pointer.

```cpp
inline T* get() const{
 if (_ptr==NULL) return NULL;
 return _ptr->get();
 }
```

--------------------------------

### Run Lazy Tiling Algorithm

Source: https://fastjet.fr/repo/doxygen-3.5.0/LazyTiling9SeparateGhosts_8cc_source.html

The main entry point for the lazy tiling algorithm. It initializes jet data, including distinguishing between real and ghost jets based on a threshold.

```cpp
void LazyTiling9SeparateGhosts::run() {
int ntot = _jets.size();
if (ntot == 0) return;

TiledJet3 * briefjets = new TiledJet3[ntot];
TiledJet3 * jetA = briefjets, * jetB;
TiledJet3 oldB = briefjets[0];

vector<int> tile_union(3*n_tile_neighbours);

TiledJet3 * head = briefjets; 

for (int i = 0; i< ntot; i++) {
bool is_ghost = _jets[i].perp2() < ghost_pt2_threshold; 
if (!is_ghost) {
_tj_set_jetinfo(jetA, i, is_ghost);
}
}
```

--------------------------------

### Initialize and Execute Cone Finder

Source: https://fastjet.fr/repo/doxygen-3.5.0/ATLASConePlugin_8cc_source.html

Demonstrates initializing an atlas::JetConeFinderTool, setting its radius and seed threshold parameters, and then executing it with a list of jets.

```C++
atlas::JetConeFinderTool stable_cone_finder;

// set the parameters
stable_cone_finder.m_coneR = _radius;
stable_cone_finder.m_seedPt = _seedPt;

// really do the search.
// Note that the list of protocones is returned 
// through the argument
stable_cone_finder.execute(jets_ptr);
```

--------------------------------

### Filter Example Program

Source: https://fastjet.fr/repo/doxygen-3.5.0/11-filter_8cc.html

This is the main function of the example program. It demonstrates how to use the Filter tool in FastJet, including its application to composite jets. Ensure all necessary FastJet headers are included.

```cpp
#include <fastjet/PseudoJet.hh>
#include <fastjet/ClusterSequence.hh>
#include <fastjet/Selector.hh>
#include <iostream>
#include "fastjet/tools/Filter.hh"
#include "fastjet/tools/GridMedianBackgroundEstimator.hh"
#include "fastjet/ClusterSequenceArea.hh"
#include "fastjet/tools/Subtractor.hh"
#include <cstdio>

int main ()
```

--------------------------------

### Build pxcone plugin

Source: https://fastjet.fr/repo/doxygen-3.5.0/INSTALL_source.html

Build the pxcone plugin, which provides Fortran support. This requires navigating to the plugin directory and using the static makefile.

```bash
make -f makefile.static pxcone
```
Tokens:
Raw