add support for GenKt

Author: m-fila

compile/README.md

@@ -60,11 +60,12 @@ int main(int argc, char *argv[]) {
   /*Call jet reconstruction*/
   jetreconstruction_JetAlgorithm algorithm = JETRECONSTRUCTION_JETALGORITHM_CA;
   double R = 3.0;
+  double power = 0.0;
   jetreconstruction_RecoStrategy strategy = JETRECONSTRUCTION_RECOSTRATEGY_BEST;
   jetreconstruction_RecombinationScheme recombination = JETRECONCSTRUCTION_RECOMBINATIONSCHEME_ESCHEME;
 
   jetreconstruction_ClusterSequence cluster_seq;
-  jetreconstruction_StatusCode sc = jetreconstruction_jet_reconstruct(particles, len, algorithm, R,
+  jetreconstruction_StatusCode sc = jetreconstruction_jet_reconstruct(particles, len, algorithm, power, R,
                                                                       strategy, recombination, &cluster_seq);
   if (sc != JETRECONSTRUCTION_STATUSCODE_OK){
     /*An error occurred check the value or stderr for more information*/

compile/downstream/jetreconstruction_test.c

@@ -65,14 +65,15 @@ int main(int argc, char *argv[]) {
   sc = jetreconstruction_PseudoJet_init(&particles[1], 1.0, 2.0, 3.0, 4.0, 2);
   assert(sc == JETRECONSTRUCTION_STATUSCODE_OK);
 
-  jetreconstruction_JetAlgorithm algorithm = JETRECONSTRUCTION_JETALGORITHM_CA;
+  jetreconstruction_JetAlgorithm algorithm = JETRECONSTRUCTION_JETALGORITHM_GENKT;
   double R = 3.0;
+  double power = 0.5;
   jetreconstruction_RecoStrategy strategy = JETRECONSTRUCTION_RECOSTRATEGY_BEST;
   jetreconstruction_RecombinationScheme recombination =
       JETRECONCSTRUCTION_RECOMBINATIONSCHEME_ESCHEME;
 
   jetreconstruction_ClusterSequence cluster_seq;
-  sc = jetreconstruction_jet_reconstruct(particles, len, algorithm, R, strategy,
+  sc = jetreconstruction_jet_reconstruct(particles, len, algorithm, power, R, strategy,
                                          recombination, &cluster_seq);
   assert(sc == JETRECONSTRUCTION_STATUSCODE_OK);
 

compile/include/JetReconstruction.h.in

@@ -247,6 +247,9 @@ static inline void jetreconstruction_ClusterSequence_free_members(
  * reconstruction.
  * @param[in] particles_length The length of @p particles array.
  * @param[in] algorithm The algorithm to use for jet reconstruction.
+ * @param[in] power  The power value used for the distance measure for
+ * generalised k_T algorithms (GenKt, EEKt). Other algorithms will ignore this
+ * value.
  * @param[in] R The jet radius parameter.
  * @param[in] strategy The jet reconstruction strategy to use.
  * @param[in] recombination_scheme The recombination scheme used for combining
@@ -258,7 +261,7 @@ static inline void jetreconstruction_ClusterSequence_free_members(
  */
 jetreconstruction_StatusCode jetreconstruction_jet_reconstruct(
     const jetreconstruction_PseudoJet *particles, size_t particles_length,
-    jetreconstruction_JetAlgorithm algorithm, double R,
+    jetreconstruction_JetAlgorithm algorithm, double power, double R,
     jetreconstruction_RecoStrategy strategy,
     jetreconstruction_RecombinationScheme recombination_scheme,
     jetreconstruction_ClusterSequence *result);

compile/precompile_execution.jl

@@ -19,6 +19,7 @@ end
 
 R = 2.0
 jets_len = Csize_t(2)
+power = 0.5
 
 ### pp jets ###
 
@@ -33,15 +34,15 @@ assert_ok(jetreconstruction_PseudoJet_init(jets_ptr, 0.0, 1.0, 2.0, 3.0, 1))
 assert_ok(jetreconstruction_PseudoJet_init(jets_ptr + sizeof(PseudoJet), 1.0, 2.0, 3.0,
                                            4.0, 2))
 
-for algorithm in [JetAlgorithm.AntiKt, JetAlgorithm.CA, JetAlgorithm.Kt],
+for algorithm in [JetAlgorithm.AntiKt, JetAlgorithm.CA, JetAlgorithm.Kt, JetAlgorithm.GenKt],
     strategy in [RecoStrategy.N2Plain, RecoStrategy.N2Tiled, RecoStrategy.Best],
     recombination in [
         RecombinationScheme.EScheme,
         RecombinationScheme.PtScheme,
         RecombinationScheme.Pt2Scheme
     ]
 
-    assert_ok(jetreconstruction_jet_reconstruct(jets_ptr, jets_len, algorithm, R,
+    assert_ok(jetreconstruction_jet_reconstruct(jets_ptr, jets_len, algorithm, power, R,
                                                 strategy, recombination,
                                                 clustersequence_ptr))
 

src/C_JetReconstruction/C_JetReconstruction.jl

@@ -231,6 +231,7 @@ end
     c_jet_reconstruct(particles::Ptr{T},
                       particles_length::Csize_t,
                       algorithm::JetAlgorithm.Algorithm,
+                      power::Cdouble,
                       R::Cdouble,
                       strategy::RecoStrategy.Strategy,
                       recombination_scheme::RecombinationScheme.Recombine,
@@ -242,6 +243,7 @@ Internal helper functions for calling `jet_reconstruct` with C-compatible data-s
 - `particles::Ptr{T}`: Pointer to an array of pseudojet objects used for jet reconstruction.
 - `particles_length::Csize_t`: The length of `particles`` array.
 - `algorithm::JetAlgorithm.Algorithm`: The algorithm to use for jet reconstruction.
+- `power::Cdouble`:  The power value used for the distance measure for generalised k_T algorithms (GenKt, EEKt). Other algorithms will ignore this value.
 - `R::Cdouble`: The jet radius parameter.
 - `strategy::RecoStrategy.Strategy`: The jet reconstruction strategy to use.
 - `recombination_scheme::RecombinationScheme.Recombine`: The recombination scheme used for combining particles.
@@ -256,13 +258,14 @@ Internal helper functions for calling `jet_reconstruct` with C-compatible data-s
 function c_jet_reconstruct(particles::Ptr{T},
                            particles_length::Csize_t,
                            algorithm::JetAlgorithm.Algorithm,
+                           power::Cdouble,
                            R::Cdouble,
                            strategy::RecoStrategy.Strategy,
                            recombination_scheme::RecombinationScheme.Recombine,
                            result::Ptr{C_ClusterSequence{U}}) where {T, U}
     try
         particles_v = unsafe_wrap(Vector{T}, particles, particles_length)
-        clusterseq = jet_reconstruct(particles_v; p = nothing, algorithm = algorithm, R = R,
+        clusterseq = jet_reconstruct(particles_v; p = power, algorithm = algorithm, R = R,
                                      strategy = strategy,
                                      RecombinationMethods[recombination_scheme]...)
         c_clusterseq = C_ClusterSequence{U}(clusterseq)
@@ -278,6 +281,7 @@ end
     jetreconstruction_jet_reconstruct(particles::Ptr{PseudoJet},
                                       particles_length::Csize_t,
                                       algorithm::JetAlgorithm.Algorithm,
+                                      power::Cdouble,
                                       R::Cdouble,
                                       strategy::RecoStrategy.Strategy,
                                       recombination_scheme::RecombinationScheme.Recombine,
@@ -289,7 +293,8 @@ C-binding for `jet_reconstruct`.
 - `particles::Ptr{PseudoJet}`: Pointer to an array of pseudojet objects used for jet reconstruction.
 - `particles_length::Csize_t`: The length of `particles`` array.
 - `algorithm::JetAlgorithm.Algorithm`: The algorithm to use for jet reconstruction.
-- `R::Cdouble`: The jet radius parameter..
+- `power::Cdouble`:  The power value used for the distance measure for generalised k_T algorithms (GenKt, EEKt). Other algorithms will ignore this value.
+- `R::Cdouble`: The jet radius parameter.
 - `strategy::RecoStrategy.Strategy`: The jet reconstruction strategy to use.
 - `recombination_scheme::RecombinationScheme.Recombine`: The recombination scheme used for combining particles.
 - `result::Ptr{C_ClusterSequence{PseudoJet}}`: A pointer to which a cluster sequence containing the reconstructed jets and the merging history will be stored.
@@ -304,11 +309,12 @@ C-binding for `jet_reconstruct`.
 Base.@ccallable function jetreconstruction_jet_reconstruct(particles::Ptr{PseudoJet},
                                                            particles_length::Csize_t,
                                                            algorithm::JetAlgorithm.Algorithm,
+                                                           power::Cdouble,
                                                            R::Cdouble,
                                                            strategy::RecoStrategy.Strategy,
                                                            recombination_scheme::RecombinationScheme.Recombine,
                                                            result::Ptr{C_ClusterSequence{PseudoJet}})::Cint
-    return c_jet_reconstruct(particles, particles_length, algorithm, R, strategy,
+    return c_jet_reconstruct(particles, particles_length, algorithm, power, R, strategy,
                              recombination_scheme, result)
 end
 

test/test-c-interface.jl

@@ -47,7 +47,7 @@ function test_pseudojet()
     struct_approx_equal(jet, c_jet)
 end
 
-function test_jet_reconstruct(filename; algorithm, R, strategy, recombine, power = nothing,
+function test_jet_reconstruct(filename; algorithm, R, strategy, recombine, power = 0.0,
                               T = PseudoJet)
     @testset "C-interface jet reconstruct" begin
         events = JetReconstruction.read_final_state_particles(filename)
@@ -62,6 +62,7 @@ function test_jet_reconstruct(filename; algorithm, R, strategy, recombine, power
             ret = C_JetReconstruction.jetreconstruction_jet_reconstruct(c_event,
                                                                         c_event_length,
                                                                         algorithm,
+                                                                        power,
                                                                         R,
                                                                         strategy,
                                                                         recombine,
@@ -139,20 +140,20 @@ end
 @testset "C-interface JetReconstruction pp" begin
     test_cone_size = 0.4
     test_recombine_scheme = RecombinationScheme.EScheme
+    test_power = 0.5
 
     test_pseudojet()
 
-    for alg in [JetAlgorithm.AntiKt, JetAlgorithm.CA, JetAlgorithm.Kt],
+    for alg in [JetAlgorithm.AntiKt, JetAlgorithm.CA, JetAlgorithm.Kt, JetAlgorithm.GenKt],
         stg in [RecoStrategy.Best, RecoStrategy.N2Plain, RecoStrategy.N2Tiled]
 
-        power = JetReconstruction.algorithm2power[alg]
-        @testset "C-interface JetReconstruction comparison: alg=$alg, p=$power, R=$test_cone_size, strategy=$stg" begin
+        @testset "C-interface JetReconstruction comparison: alg=$alg, R=$test_cone_size, strategy=$stg" begin
             cluster_seq_ptrs, cluster_seqs = test_jet_reconstruct(events_file_pp;
                                                                   algorithm = alg,
                                                                   strategy = stg,
                                                                   recombine = test_recombine_scheme,
                                                                   R = test_cone_size,
-                                                                  power = power)
+                                                                  power = test_power)
             test_inclusive_jets(cluster_seq_ptrs, cluster_seqs; ptmin = 5.0)
             if alg != JetAlgorithm.AntiKt
                 test_exclusive_jets_njets(cluster_seq_ptrs, cluster_seqs; njets = 4)