Make SoftKiller immutable (#179)

* fix and

* make softkiller immutable struct

* reorder fields to match constructors

* change `Int64` to `Int`

Co-authored-by: Jerry Ling <[email protected]>

---------

Co-authored-by: Jerry Ling <[email protected]>

Author: m-fila

src/SoftKiller.jl

@@ -1,7 +1,7 @@
 using Statistics
 
 """
-    mutable struct SoftKiller
+    struct SoftKiller
 
 Implements the SoftKiller pileup mitigation algorithm, inspired by the FastJet contrib package.
 
@@ -21,14 +21,14 @@ are removed from the event.
 - `_ymin::Float64`: Minimum rapidity of the grid.
 - `_requested_drap::Float64`: Requested grid spacing in rapidity.
 - `_requested_dphi::Float64`: Requested grid spacing in phi.
-- `_ntotal::Int64`: Total number of tiles.
+- `_ntotal::Int`: Total number of tiles.
 - `_dy::Float64`: Actual grid spacing in rapidity.
 - `_dphi::Float64`: Actual grid spacing in phi.
 - `_cell_area::Float64`: Area of a single tile.
 - `_inverse_dy::Float64`: Inverse of rapidity grid spacing.
 - `_inverse_dphi::Float64`: Inverse of phi grid spacing.
-- `_ny::Int64`: Number of tiles in rapidity.
-- `_nphi::Int64`: Number of tiles in phi.
+- `_ny::Int`: Number of tiles in rapidity.
+- `_nphi::Int`: Number of tiles in phi.
 
 # Constructors
 - `SoftKiller(rapmin::Float64, rapmax::Float64, drap::Float64, dphi::Float64)`: 
@@ -37,19 +37,19 @@ are removed from the event.
   Construct a square grid from `-rapmax` to `rapmax` in rapidity, with tile size `grid_size`.
 
 """
-mutable struct SoftKiller
-    _ymax::Float64
+struct SoftKiller
     _ymin::Float64
+    _ymax::Float64
     _requested_drap::Float64
     _requested_dphi::Float64
-    _ntotal::Int64
+    _ntotal::Int
     _dy::Float64
     _dphi::Float64
     _cell_area::Float64
     _inverse_dy::Float64
     _inverse_dphi::Float64
-    _ny::Int64
-    _nphi::Int64
+    _ny::Int
+    _nphi::Int
 
     """
         SoftKiller(rapmin::Float64, rapmax::Float64, drap::Float64, dphi::Float64)
@@ -58,9 +58,26 @@ mutable struct SoftKiller
     """
 
     function SoftKiller(rapmin::Float64, rapmax::Float64, drap::Float64, dphi::Float64)
-        grid = new(rapmax, rapmin, drap, dphi, 0, 0.0, 0.0, 0.0, 0.0, 0.0, 0, 0)
-        _setup_grid!(grid)
-        grid
+        @assert rapmax > rapmin
+        @assert drap > 0
+        @assert dphi > 0
+
+        ny_double = (rapmax - rapmin) / drap
+        ny = max(round(Int, ny_double + 0.5), 1)
+        dy = (rapmax - rapmin) / ny
+        inverse_dy = ny / (rapmax - rapmin)
+
+        nphi = round(Int, (2 * π) / dphi + 0.5)
+        dphi_final = (2 * π) / nphi
+        inverse_dphi = nphi / (2 * π)
+
+        @assert ny >= 1 && nphi >= 1
+
+        ntotal = nphi * ny
+        cell_area = dy * dphi_final
+
+        new(rapmin, rapmax, drap, dphi, ntotal, dy, dphi_final, cell_area,
+            inverse_dy, inverse_dphi, ny, nphi)
     end
 
     """
@@ -69,10 +86,7 @@ mutable struct SoftKiller
     Construct a square SoftKiller grid from `-rapmax` to `rapmax` in rapidity, with tile size `grid_size`.
     """
     function SoftKiller(rapmax::Float64, grid_size::Float64)
-        grid = new(rapmax, -rapmax, grid_size, grid_size, 0, 0.0, 0.0, 0.0, 0.0, 0.0, 0,
-                   0)
-        _setup_grid!(grid)
-        grid
+        return SoftKiller(-rapmax, rapmax, grid_size, grid_size)
     end
 end
 
@@ -88,46 +102,21 @@ function tile_index(sk::SoftKiller, p::PseudoJet)
         return -1
     end
 
-    iy = round(Int64, y_minus_ymin * sk._inverse_dy)
+    iy = round(Int, y_minus_ymin * sk._inverse_dy)
     if iy >= sk._ny
         return -1
     end
 
-    iphi = round(Int64, phi(p) * sk._inverse_dphi)
+    iphi = round(Int, phi(p) * sk._inverse_dphi)
     if iphi == sk._nphi
         iphi = 0
     end
 
-    res = round(Int64, iy * sk._nphi + iphi)
+    res = round(Int, iy * sk._nphi + iphi)
 
     res + 1
 end
 
-"""
-    _setup_grid!(sk::SoftKiller)
-
-Internal function to initialize the grid parameters for a `SoftKiller` instance.
-"""
-function _setup_grid!(sk::SoftKiller)
-    @assert sk._ymax > sk._ymin
-    @assert sk._requested_drap > 0
-    @assert sk._requested_dphi > 0
-
-    ny_double = (sk._ymax - sk._ymin) / sk._requested_drap
-    sk._ny = max(round(Int64, ny_double + 0.5), 1)
-    sk._dy = (sk._ymax - sk._ymin) / sk._ny
-    sk._inverse_dy = sk._ny / (sk._ymax - sk._ymin)
-
-    sk._nphi = round(Int64, (2 * π) / sk._requested_dphi + 0.5)
-    sk._dphi = (2 * π) / sk._nphi
-    sk._inverse_dphi = sk._nphi / (2 * π)
-
-    @assert sk._ny>=1 and sk._nphi>=1
-
-    sk._ntotal = sk._nphi * sk._ny
-    sk._cell_area = sk._dy * sk._dphi
-end
-
 import Base: show
 
 """