add recombination schemes to C-bindings

Author: m-fila

compile/README.md

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

compile/downstream/jetreconstruction_test.c

@@ -54,7 +54,7 @@ void printJetsResult(const jetreconstruction_JetsResult *results) {
 
 int main(int argc, char *argv[]) {
   clock_t start_time = clock();
-  int sc = 0;
+  jetreconstruction_StatusCode sc = 0;
 #ifdef JETRECONSTRUCTION_COMPILER_PACKAGECOMPILER
   init_julia(0, NULL);
 #endif
@@ -68,10 +68,12 @@ int main(int argc, char *argv[]) {
   jetreconstruction_JetAlgorithm algorithm = JETRECONSTRUCTION_JETALGORITHM_CA;
   double R = 3.0;
   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,
-                                         &cluster_seq);
+                                         recombination, &cluster_seq);
   assert(sc == JETRECONSTRUCTION_STATUSCODE_OK);
 
   printClusterSequence(&cluster_seq);

compile/include/JetReconstruction.h.in

@@ -103,6 +103,17 @@ typedef enum {
   JETRECONSTRUCTION_RECOSTRATEGY_N2TILTED = 2 /**< The tiled N2 strategy. */
 } jetreconstruction_RecoStrategy;
 
+/**
+ * @enum jetreconstruction_RecombinationScheme
+ * @brief Enumeration representing the different recombination schemes used in
+ * jet reconstruction.
+ */
+typedef enum {
+  JETRECONCSTRUCTION_RECOMBINATIONSCHEME_ESCHEME = 0,
+  JETRECONCSTRUCTION_RECOMBINATIONSCHEME_PTSCHEME = 1,
+  JETRECONCSTRUCTION_RECOMBINATIONSCHEME_PT2SCHEME = 2,
+} jetreconstruction_RecombinationScheme;
+
 /**
  * @struct jetreconstruction_PseudoJet
  * @brief A struct representing a pseudojet, a four-momentum object used in
@@ -138,7 +149,8 @@ typedef struct {
  */
 jetreconstruction_StatusCode
 jetreconstruction_PseudoJet_init(jetreconstruction_PseudoJet *ptr, double px,
-                                 double py, double pz, double E, long cluter_hist_index);
+                                 double py, double pz, double E,
+                                 long cluter_hist_index);
 
 /**
  * @struct jetreconstruction_HistoryElement
@@ -235,6 +247,8 @@ static inline void jetreconstruction_ClusterSequence_free_members(
  * @param[in] algorithm The algorithm to use for jet reconstruction.
  * @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
+ * particles.
  * @param[out] result A pointer to which a cluster sequence containing the
  * reconstructed jets and the merging history will be stored.
  * @return An integer status code indicating the success or failure. See common
@@ -244,6 +258,7 @@ jetreconstruction_StatusCode jetreconstruction_jet_reconstruct(
     const jetreconstruction_PseudoJet *particles, size_t particles_length,
     jetreconstruction_JetAlgorithm algorithm, double R,
     jetreconstruction_RecoStrategy strategy,
+    jetreconstruction_RecombinationScheme recombination_scheme,
     jetreconstruction_ClusterSequence *result);
 
 /**

compile/precompile_execution.jl

@@ -1,7 +1,7 @@
 # Dummy code to call and cache compilation of all C-bindings
 # The numeric values don't make sense and are used only to select correct dispatch
 
-using JetReconstruction: PseudoJet, RecoStrategy, JetAlgorithm
+using JetReconstruction: PseudoJet, RecoStrategy, JetAlgorithm, RecombinationScheme
 using JetReconstruction.C_JetReconstruction: jetreconstruction_PseudoJet_init,
                                              C_ClusterSequence,
                                              jetreconstruction_ClusterSequence_free_members_,
@@ -33,27 +33,33 @@ 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 strategy in [RecoStrategy.N2Plain, RecoStrategy.N2Tiled, RecoStrategy.Best]
-        assert_ok(jetreconstruction_jet_reconstruct(jets_ptr, jets_len, algorithm, R,
-                                                    strategy,
-                                                    clustersequence_ptr))
+for algorithm in [JetAlgorithm.AntiKt, JetAlgorithm.CA, JetAlgorithm.Kt],
+    strategy in [RecoStrategy.N2Plain, RecoStrategy.N2Tiled, RecoStrategy.Best],
+    recombination in [
+        RecombinationScheme.EScheme,
+        RecombinationScheme.PtScheme,
+        RecombinationScheme.Pt2Scheme
+    ]
 
-        assert_ok(jetreconstruction_inclusive_jets(clustersequence_ptr, 0.0, results_ptr))
-        jetreconstruction_JetsResult_free_members_(results_ptr)
+    assert_ok(jetreconstruction_jet_reconstruct(jets_ptr, jets_len, algorithm, R,
+                                                strategy, recombination,
+                                                clustersequence_ptr))
+
+    assert_ok(jetreconstruction_inclusive_jets(clustersequence_ptr, 0.0,
+                                               results_ptr))
+    jetreconstruction_JetsResult_free_members_(results_ptr)
 
-        if algorithm != JetAlgorithm.AntiKt
-            assert_ok(jetreconstruction_exclusive_jets_njets(clustersequence_ptr,
-                                                             Csize_t(2),
-                                                             results_ptr))
-            jetreconstruction_JetsResult_free_members_(results_ptr)
+    if algorithm != JetAlgorithm.AntiKt
+        assert_ok(jetreconstruction_exclusive_jets_njets(clustersequence_ptr,
+                                                         Csize_t(2),
+                                                         results_ptr))
+        jetreconstruction_JetsResult_free_members_(results_ptr)
 
-            assert_ok(jetreconstruction_exclusive_jets_dcut(clustersequence_ptr, 1.0,
-                                                            results_ptr))
-            jetreconstruction_JetsResult_free_members_(results_ptr)
+        assert_ok(jetreconstruction_exclusive_jets_dcut(clustersequence_ptr, 1.0,
+                                                        results_ptr))
+        jetreconstruction_JetsResult_free_members_(results_ptr)
 
-            jetreconstruction_ClusterSequence_free_members_(clustersequence_ptr)
-        end
+        jetreconstruction_ClusterSequence_free_members_(clustersequence_ptr)
     end
 end
 Libc.free(jets_ptr)

src/C_JetReconstruction/C_JetReconstruction.jl

@@ -3,9 +3,10 @@ Minimal C bindings for JetReconstruction.jl
 """
 module C_JetReconstruction
 
-using ..JetReconstruction: JetAlgorithm, RecoStrategy, PseudoJet, ClusterSequence,
-                           HistoryElement, jet_reconstruct,
-                           exclusive_jets, inclusive_jets
+using ..JetReconstruction: JetAlgorithm, RecoStrategy,
+                           RecombinationScheme, RecombinationMethods,
+                           PseudoJet, ClusterSequence, HistoryElement,
+                           jet_reconstruct, exclusive_jets, inclusive_jets
 using EnumX
 
 """
@@ -225,6 +226,7 @@ end
                       algorithm::JetAlgorithm.Algorithm,
                       R::Cdouble,
                       strategy::RecoStrategy.Strategy,
+                      recombination_scheme::RecombinationScheme.Recombine,
                       result::Ptr{C_ClusterSequence{U}})::Cint where {T, U}
 
 Internal helper functions for calling `jet_reconstruct` with C-compatible data-structers.
@@ -233,8 +235,9 @@ 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.
-- `R::Cdouble`: The jet radius parameter..
+- `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{U}}`: A pointer to which a cluster sequence containing the reconstructed jets and the merging history will be stored.
 
 # Returns
@@ -248,11 +251,13 @@ function c_jet_reconstruct(particles::Ptr{T},
                            algorithm::JetAlgorithm.Algorithm,
                            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,
-                                     strategy = strategy)
+                                     strategy = strategy,
+                                     RecombinationMethods[recombination_scheme]...)
         c_clusterseq = C_ClusterSequence{U}(clusterseq)
         unsafe_store!(result, c_clusterseq)
     catch e
@@ -267,6 +272,7 @@ end
                                       algorithm::JetAlgorithm.Algorithm,
                                       R::Cdouble,
                                       strategy::RecoStrategy.Strategy,
+                                      recombination_scheme::RecombinationScheme.Recombine,
                                       result::Ptr{C_ClusterSequence{PseudoJet}})::Cint
 
 C-binding for `jet_reconstruct`.
@@ -277,6 +283,7 @@ C-binding for `jet_reconstruct`.
 - `algorithm::JetAlgorithm.Algorithm`: The algorithm to use for jet reconstruction.
 - `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.
 
 # Returns
@@ -290,8 +297,10 @@ Base.@ccallable function jetreconstruction_jet_reconstruct(particles::Ptr{Pseudo
                                                            algorithm::JetAlgorithm.Algorithm,
                                                            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, result)
+    return c_jet_reconstruct(particles, particles_length, algorithm, 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, power = nothing,
+function test_jet_reconstruct(filename; algorithm, R, strategy, recombine, power = nothing,
                               T = PseudoJet)
     @testset "C-interface jet reconstruct" begin
         events = JetReconstruction.read_final_state_particles(filename)
@@ -64,13 +64,15 @@ function test_jet_reconstruct(filename; algorithm, R, strategy, power = nothing,
                                                                         algorithm,
                                                                         R,
                                                                         strategy,
+                                                                        recombine,
                                                                         cluster_seq_ptr)
             @test C_JetReconstruction.StatusCode.T(ret) == C_JetReconstruction.StatusCode.OK
 
             cluster_seq = JetReconstruction.jet_reconstruct(event; R = R,
                                                             p = power,
                                                             algorithm = algorithm,
-                                                            strategy = strategy)
+                                                            strategy = strategy,
+                                                            RecombinationMethods[recombine]...)
             compare_results(cluster_seq_ptr, cluster_seq)
             @inbounds results[ievent] = cluster_seq
             @inbounds c_results[ievent] = cluster_seq_ptr
@@ -136,6 +138,7 @@ end
 
 @testset "C-interface JetReconstruction pp" begin
     test_cone_size = 0.4
+    test_recombine_scheme = RecombinationScheme.EScheme
 
     test_pseudojet()
 
@@ -147,6 +150,7 @@ end
             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)
             test_inclusive_jets(cluster_seq_ptrs, cluster_seqs; ptmin = 5.0)