Update FieldParticleContainer to support arbitrary dimensions and abstract boxing

src/fieldcontainers.jl

@@ -6,87 +6,90 @@ export FieldParticleContainer, FieldParticleObstacleContainer
 ###########################################################################################
 #                Field Particle Container : Use BoxGrid - no obstacles                   #
 ###########################################################################################
-
-# both Field*Containers IGNORE THE DIMENSION PARAMETER and ONLY WORK IN 2D!!!!!111!!
-
-mutable struct FieldParticleContainer{N, PT <: AbstractParticle, FT} <: AbstractParticleContainer{N}
+mutable struct FieldParticleContainer{N, PT<:AbstractParticle, FT} <: AbstractParticleContainer{N}
     particles::Vector{PT}
     field::Vector{FT}
-    boxgrid::BoxGrid{2, Float64, PT}
-    function FieldParticleContainer{N, PT, FT}() where {N, PT, FT}
-        if N != 2
-            @warn "FieldParticleContainer does not work with N ≠ 2 (yet)"
-        end
-        return new{2,PT, FT}(PT[], FT[])
+    boxgrid::AbstractBoxing  # Store any boxing type here (BoxGrid or NoBoxing)
+
+    function FieldParticleContainer{N, PT, FT}() where {N, PT<:AbstractParticle, FT}
+        # Instead of calling BoxGrid{N,Float64,PT}(), default to a no-op boxing
+        return new{N, PT, FT}(PT[], FT[], NoBoxing())
     end
 end
 
-FieldParticleContainer(PT::Type{<:AbstractParticle}, FT) = FieldParticleContainer{2, PT, FT}()
 
-function initialize_pc!(sim::Simulation{<:FieldParticleContainer{N, PT}}) where {N, PT <: AbstractParticle}
+function FieldParticleContainer(PT::Type{<:AbstractParticle}, FT, N::Int) 
+    return FieldParticleContainer{N, PT, FT}()
+end
+
+function FieldParticleContainer(PT::Type{<:AbstractParticle{N}}, FT) where {N}
+    return FieldParticleContainer{N, PT, FT}()
+end
+
+
+function initialize_pc!(sim::Simulation{<:FieldParticleContainer{N, PT, FT}}) where {N, PT<:AbstractParticle, FT}
+    # The 'BoxGrid{N,Float64,PT}(sim)' constructor calls `BoxGrid(sim)`
     sim.particles.boxgrid = BoxGrid{N, Float64, PT}(sim)
     return nothing
 end
 
-Base.push!(pc::FieldParticleContainer, x) = push!(pc.particles, x)
-Base.append!(pc::FieldParticleContainer, xs) = append!(pc.particles, xs)
+
+Base.push!(pc::FieldParticleContainer, p) = push!(pc.particles, p)
+Base.append!(pc::FieldParticleContainer, ps) = append!(pc.particles, ps)
 
 InPartS.particles(sim::Simulation{<:FieldParticleContainer}) = sim.particles.particles
-InPartS.particletype(::FieldParticleContainer{N, PT}) where {N, PT} = PT
-InPartS.flushadditions!(pc::FieldParticleContainer, ab::Vector) = flushadditions!(pc.particles, ab)
-InPartS.flushdeletions!(pc::FieldParticleContainer, db) = flushdeletions!(pc.particles, db)
+InPartS.particletype(::FieldParticleContainer{N, PT, FT}) where {N, PT, FT} = PT
+
+InPartS.flushadditions!(pc::FieldParticleContainer, newparticles::Vector) = flushadditions!(pc.particles, newparticles)
+InPartS.flushdeletions!(pc::FieldParticleContainer, rmids) = flushdeletions!(pc.particles, rmids)
 InPartS.findbyid(pc::FieldParticleContainer, id) = findbyid(pc.particles, id)
+
 InPartS.setparticles!(pc::FieldParticleContainer, ps) = (empty!(pc.particles); append!(pc.particles, ps))
 InPartS.alldynamicobjects(sim::Simulation{<:FieldParticleContainer}) = vcat(sim.particles.particles, sim.particles.field)
-
-## FORCE COMPUTATION ###########################################################
-
-@forcedef function computeforces!(sim::Simulation{<:FieldParticleContainer})
+@forcedef function InPartS.computeforces!(sim::Simulation{<:FieldParticleContainer})
     pc = sim.particles
+    # Pairwise interactions among particles
     pairwise_interactions(externalforces!, sim, pc.boxgrid)
-    for p in particles(sim)
+    
+    # Internal forces (e.g. springs) for each particle
+    for p in pc.particles
         internalforces!(p, sim)
     end
-
-    for f in pc.field # maybe more than one field
-        for p in particles(sim)
+    
+    # Field–particle interactions
+    for f in pc.field
+        for p in pc.particles
             fieldinteraction!(f, p, sim)
         end
     end
 end
-
-function Base.show(io::IO, ::MIME"text/plain", pc::FieldParticleContainer{PT}) where {PT}
-    print(io,
-"""FieldParticleContainer{$PT}
-    \t$(PT): $(length(pc.particles))"""
-    )
-end
-
-
-
-# This definition is not strictly necessary but should help with speed
 function InPartS.propagate!(sim::Simulation{<:FieldParticleContainer}, dt)
-    for particle ∈ particles(sim)
+    # Step each particle
+    for particle in particles(sim)
         InPartS.step!(particle, dt, sim)
     end
-
-    for field in sim.particles.field
-        InPartS.step!(field, dt, sim)
+    # Step each field
+    for f in sim.particles.field
+        InPartS.step!(f, dt, sim)
     end
-
+    
     flushdeletions!(sim)
     flushadditions!(sim)
 
-    for particle ∈ particles(sim)
+    # Let each particle fold back into domain if needed, then reset
+    for particle in particles(sim)
         fold_back!(particle, sim.domain)
         reset!(particle, sim)
     end
-
-
     return nothing
 end
 
-
+# Printing
+function Base.show(io::IO, ::MIME"text/plain", pc::FieldParticleContainer{N, PT, FT}) where {N, PT, FT}
+    print(io, "FieldParticleContainer{$N, $PT, $FT}\n")
+    print(io, "   #particles = ", length(pc.particles), "\n")
+    print(io, "   #fields    = ", length(pc.field), "\n")
+end
 
 ###########################################################################################
 #                Field Particle Obstacle Container : Use BoxGrid - obstacles                   #