From ffd831ea3c939f831b8d9a350c3db9591df133e7 Mon Sep 17 00:00:00 2001 From: Anton Reinhard Date: Thu, 12 Oct 2023 16:13:17 +0200 Subject: [PATCH] Remove particle interface, implementation and tests, they moved to QEDbase (#23) Fixes #22 Co-authored-by: AntonReinhard --- src/QEDprocesses.jl | 12 -- src/interfaces/particle_interface.jl | 80 ----------- src/interfaces/setup_interface.jl | 2 +- src/particle_types.jl | 192 -------------------------- test/interfaces/particle_interface.jl | 30 ---- test/particle_types.jl | 75 ---------- test/runtests.jl | 6 - 7 files changed, 1 insertion(+), 396 deletions(-) delete mode 100644 src/interfaces/particle_interface.jl delete mode 100644 src/particle_types.jl delete mode 100644 test/interfaces/particle_interface.jl delete mode 100644 test/particle_types.jl diff --git a/src/QEDprocesses.jl b/src/QEDprocesses.jl index b595481..5963892 100644 --- a/src/QEDprocesses.jl +++ b/src/QEDprocesses.jl @@ -1,9 +1,5 @@ module QEDprocesses -export AbstractParticle -export is_fermion, is_boson, is_particle, is_anti_particle -export mass, charge - # Abstract model interface export AbstractModelDefinition, fundamental_interaction_type @@ -17,19 +13,11 @@ export differential_cross_section, total_cross_section export AbstractComputationSetup, InvalidInputError, compute export AbstractProcessSetup, scattering_process, physical_model -# particle types -export AbstractParticleType -export FermionLike, Fermion, AntiFermion, MajoranaFermion -export BosonLike, Boson, AntiBoson, MajoranaBoson -export Electron, Positron, Photon - using DocStringExtensions using QEDbase include("utils.jl") -include("interfaces/particle_interface.jl") include("interfaces/model_interface.jl") include("interfaces/process_interface.jl") include("interfaces/setup_interface.jl") -include("particle_types.jl") end diff --git a/src/interfaces/particle_interface.jl b/src/interfaces/particle_interface.jl deleted file mode 100644 index 1f95ef7..0000000 --- a/src/interfaces/particle_interface.jl +++ /dev/null @@ -1,80 +0,0 @@ -############### -# The paricle interface -# -# In this file, we define the interface for working with particles in a general -# sense. -############### - - -""" -Abstract base type for every type which might be considered a *particle* in the context of `QED.jl`. For every (concrete) subtype of `AbstractParticle`, there are two kinds of interface functions implemented: static functions and property functions. -The static functions provide information on what kind of particle it is (defaults are written in square brackets) - -```julia - is_fermion(::AbstractParticle)::Bool [= false] - is_boson(::AbstractParticle)::Bool [= false] - is_particle(::AbstractParticle)::Bool [= true] - is_anti_particle(::AbstractParticle)::Bool [= false] -``` -If the output of those functions differ from the defaults for a subtype of `AbstractParticle`, these functions need to be overwritten. -The second type of functions define a hard interface for `AbstractParticle`: - -```julia - mass(::AbstractParticle)::Real - charge(::AbstractParticle)::Real -``` -These functions must be implemented in order to have the subtype of `AbstractParticle` work with the functionalities of `QEDprocesses.jl`. -""" -abstract type AbstractParticle end - -""" - $(TYPEDSIGNATURES) - -Interface function for particles. Return `true` if the passed subtype of `AbstractParticle` can be considered a *fermion* in the sense of particle statistics, and `false` otherwise. -The default implementation of `is_fermion` for every subtype of `AbstractParticle` will always return `false`. -""" -is_fermion(::AbstractParticle) = false - -""" - $(TYPEDSIGNATURES) - -Interface function for particles. Return `true` if the passed subtype of `AbstractParticle` can be considered a *boson* in the sense of particle statistics, and `false` otherwise. -The default implementation of `is_boson` for every subtype of `AbstractParticle` will always return `false`. -""" -is_boson(::AbstractParticle) = false - -""" - $(TYPEDSIGNATURES) - -Interface function for particles. Return `true` if the passed subtype of `AbstractParticle` can be considered a *particle* as distinct from anti-particles, and `false` otherwise. -The default implementation of `is_particle` for every subtype of `AbstractParticle` will always return `true`. -""" -is_particle(::AbstractParticle) = true - -""" - $(TYPEDSIGNATURES) - -Interface function for particles. Return true if the passed subtype of `AbstractParticle` can be considered an *anti particle* as distinct from their particle counterpart, and `false` otherwise. -The default implementation of `is_anti_particle` for every subtype of `AbstractParticle` will always return `false`. -""" -is_anti_particle(::AbstractParticle) = false - -""" - - mass(particle::AbstractParticle)::Real - -Interface function for particles. Return the rest mass of a particle (in units of the electron mass). - -This needs to be implemented for each concrete subtype of `AbstractParticle`. -""" -function mass end - -""" - - charge(::AbstractParticle)::Real - -Interface function for particles. Return the electric charge of a particle (in units of the elementary electric charge). - -This needs to be implemented for each concrete subtype of `AbstractParticle`. -""" -function charge end diff --git a/src/interfaces/setup_interface.jl b/src/interfaces/setup_interface.jl index 19e8122..035f3b9 100644 --- a/src/interfaces/setup_interface.jl +++ b/src/interfaces/setup_interface.jl @@ -98,7 +98,7 @@ Interface function, which asserts that the given `input` is valid, and throws an ```Julia _assert_valid_input(stp::YourCustomSetup,input) ``` - which should throw an exception, which is a subtype of [`AbstractInvalidInputError`](@ref). One may also use the concrete implementation [`InvalidInputError`](@ref) if the input is invalid instead of writing a custom exception type. + which should throw an exception, which is a subtype of [`AbstractInvalidInputException`](@ref). One may also use the concrete implementation [`InvalidInputError`](@ref) if the input is invalid instead of writing a custom exception type. """ @inline function _assert_valid_input(stp::AbstractComputationSetup, input) diff --git a/src/particle_types.jl b/src/particle_types.jl deleted file mode 100644 index 10580ef..0000000 --- a/src/particle_types.jl +++ /dev/null @@ -1,192 +0,0 @@ -############### -# The particle types -# -# In this file, we define the types of particles used in `QEDprocesses.jl` and -# implement the abstact particle interface accordingly. -############### - -""" - AbstractParticleType <: AbstractParticle - -This is the abstract base type for every species of particles. All functionalities defined on subtypes of `AbstractParticleType` should be static, i.e. known at compile time. -For adding runtime information, e.g. four-momenta or particle states, to a particle, consider implementing a concrete subtype of `AbstractParticle` instead, which may have a type parameter `P<:AbstractParticleType`. See the concrete type `Particle{P,ST,MT}` - -Concrete built-in subtypes of `AbstractParticleType` are - -```julia - Electron - Positron - Photon -``` - -""" -abstract type AbstractParticleType <: AbstractParticle end - -""" -Abstract base types for particle species that act like fermions in the sense of particle statistics. - -!!! note "particle interface" - Every concrete subtype of `FermionLike` has `is_fermion(::FermionLike) = true`. -""" -abstract type FermionLike <: AbstractParticleType end - -Base.@pure is_fermion(::FermionLike) = true - -""" -Abstract base type for fermions as distinct from anti-fermions. - -!!! note "particle interface" - All subtypes of `Fermion` have - ```julia - is_fermion(::Fermion) = true - is_particle(::Fermion) = true - is_anti_particle(::Fermion) = false - ``` - -""" -abstract type Fermion <: FermionLike end - -is_particle(::Fermion) = true - -is_anti_particle(::Fermion) = false - -""" -Abstract base type for anti-fermions as distinct from its particle counterpart `Fermion`. - -!!! note "particle interface" - All subtypes of `AntiFermion` have - ```julia - is_fermion(::AntiFermion) = true - is_particle(::AntiFermion) = false - is_anti_particle(::AntiFermion) = true - ``` - -""" -abstract type AntiFermion <: FermionLike end - -is_particle(::AntiFermion) = false - -is_anti_particle(::AntiFermion) = true - -""" -Abstract base type for majorana-fermions, i.e. fermions which are their own anti-particles. - -!!! note "particle interface" - All subtypes of `MajoranaFermion` have - ```julia - is_fermion(::MajoranaFermion) = true - is_particle(::MajoranaFermion) = true - is_anti_particle(::MajoranaFermion) = true - ``` - -""" -abstract type MajoranaFermion <: FermionLike end - -is_particle(::MajoranaFermion) = true - -is_anti_particle(::MajoranaFermion) = true - -""" -Concrete type for *electrons* as a particle species. Mostly used for dispatch. - -!!! note "particle interface" - Besides being a subtype of `Fermion`, objects of type `Electron` have - - ```julia - mass(::Electron) = 1.0 - charge(::Electron) = -1.0 - ``` -""" -struct Electron <: Fermion end -mass(::Electron) = 1.0 -charge(::Electron) = -1.0 - -""" -Concrete type for *positrons* as a particle species. Mostly used for dispatch. - -!!! note "particle interface" - Besides being a subtype of `AntiFermion`, objects of type `Positron` have - - ```julia - mass(::Positron) = 1.0 - charge(::Positron) = 1.0 - ``` - -""" -struct Positron <: AntiFermion end -mass(::Positron) = 1.0 -charge(::Positron) = 1.0 - -""" -Abstract base types for particle species that act like bosons in the sense of particle statistics. - -!!! note "particle interface" - Every concrete subtype of `BosonLike` has `is_boson(::BosonLike) = true`. -""" -abstract type BosonLike <: AbstractParticleType end - -is_boson(::BosonLike) = true - -""" -Abstract base type for bosons as distinct from its anti-particle counterpart `AntiBoson`. - -!!! note "particle interface" - All subtypes of `Boson` have - ```julia - is_boson(::Boson) = true - is_particle(::Boson) = true - is_anti_particle(::Boson) = false - ``` - -""" -abstract type Boson <: BosonLike end -is_particle(::Boson) = true -is_anti_particle(::Boson) = false - -""" -Abstract base type for anti-bosons as distinct from its particle counterpart `Bosons`. - -!!! note "particle interface" - All subtypes of `AntiBoson` have - ```julia - is_boson(::AntiBoson) = true - is_particle(::AntiBoson) = false - is_anti_particle(::AntiBoson) = true - ``` - -""" -abstract type AntiBoson <: BosonLike end -is_particle(::AntiBoson) = false -is_anti_particle(::AntiBoson) = true - -""" -Abstract base type for majorana-bosons, i.e. bosons which are their own anti-particles. - -!!! note "particle interface" - All subtypes of `MajoranaBoson` have - ```julia - is_boson(::MajoranaBoson) = true - is_particle(::MajoranaBoson) = true - is_anti_particle(::MajoranaBoson) = true - ``` - -""" -abstract type MajoranaBoson <: BosonLike end -is_particle(::MajoranaBoson) = true -is_anti_particle(::MajoranaBoson) = true - -""" -Concrete type for the *photons* as a particle species. Mostly used for dispatch. - -!!! note "particle interface" - Besides being a subtype of `MajoranaBoson`, `Photon` has - - ```julia - mass(::Photon) = 0.0 - charge(::Photon) = 0.0 - ``` - -""" -struct Photon <: MajoranaBoson end -mass(::Photon) = 0.0 -charge(::Photon) = 0.0 diff --git a/test/interfaces/particle_interface.jl b/test/interfaces/particle_interface.jl deleted file mode 100644 index d803b18..0000000 --- a/test/interfaces/particle_interface.jl +++ /dev/null @@ -1,30 +0,0 @@ - -using Random -using QEDprocesses - -RNG = MersenneTwister(137137137) - -RND_MASS = rand(RNG) -RND_CHARGE = rand(RNG) - -struct TestParticle <: AbstractParticle end -QEDprocesses.mass(::TestParticle) = RND_MASS -QEDprocesses.charge(::TestParticle) = RND_CHARGE - -@testset "default interface" begin - @test !is_fermion(TestParticle()) - @test !is_boson(TestParticle()) - @test is_particle(TestParticle()) - @test !is_anti_particle(TestParticle()) -end - -@testset "hard interface" begin - @test mass(TestParticle()) == RND_MASS - @test charge(TestParticle()) == RND_CHARGE -end - -struct TestParticle_FAIL <: AbstractParticle end -@testset "interface fail" begin - @test_throws MethodError charge(TestParticle_FAIL()) - @test_throws MethodError mass(TestParticle_FAIL()) -end diff --git a/test/particle_types.jl b/test/particle_types.jl deleted file mode 100644 index cf59607..0000000 --- a/test/particle_types.jl +++ /dev/null @@ -1,75 +0,0 @@ -using QEDprocesses - -@testset "fermion likes" begin - @testset "fermion" begin - struct TestFermion <: Fermion end - @test is_fermion(TestFermion()) - @test is_particle(TestFermion()) - @test !is_anti_particle(TestFermion()) - end - - @testset "antifermion" begin - struct TestAntiFermion <: AntiFermion end - @test is_fermion(TestAntiFermion()) - @test !is_particle(TestAntiFermion()) - @test is_anti_particle(TestAntiFermion()) - end - - @testset "majorana fermion" begin - struct TestMajoranaFermion <: MajoranaFermion end - @test is_fermion(TestMajoranaFermion()) - @test is_particle(TestMajoranaFermion()) - @test is_anti_particle(TestMajoranaFermion()) - end - - @testset "electron" begin - @test is_fermion(Electron()) - @test is_particle(Electron()) - @test !is_anti_particle(Electron()) - @test mass(Electron()) == 1.0 - @test charge(Electron()) == -1.0 - end - - @testset "positron" begin - @test is_fermion(Positron()) - @test !is_particle(Positron()) - @test is_anti_particle(Positron()) - @test mass(Positron()) == 1.0 - @test charge(Positron()) == 1.0 - end -end - -@testset "boson likes" begin - @testset "boson" begin - struct TestBoson <: Boson end - @test !is_fermion(TestBoson()) - @test is_boson(TestBoson()) - @test is_particle(TestBoson()) - @test !is_anti_particle(TestBoson()) - end - - @testset "antiboson" begin - struct TestAntiBoson <: AntiBoson end - @test !is_fermion(TestAntiBoson()) - @test is_boson(TestAntiBoson()) - @test !is_particle(TestAntiBoson()) - @test is_anti_particle(TestAntiBoson()) - end - - @testset "majorana boson" begin - struct TestMajoranaBoson <: MajoranaBoson end - @test !is_fermion(TestMajoranaBoson()) - @test is_boson(TestMajoranaBoson()) - @test is_particle(TestMajoranaBoson()) - @test is_anti_particle(TestMajoranaBoson()) - end - - @testset "photon" begin - @test !is_fermion(Photon()) - @test is_boson(Photon()) - @test is_particle(Photon()) - @test is_anti_particle(Photon()) - @test charge(Photon()) == 0.0 - @test mass(Photon()) == 0.0 - end -end diff --git a/test/runtests.jl b/test/runtests.jl index 4771120..90bf7b3 100644 --- a/test/runtests.jl +++ b/test/runtests.jl @@ -4,9 +4,6 @@ using SafeTestsets begin # Interfaces - @time @safetestset "particle interface" begin - include("interfaces/particle_interface.jl") - end @time @safetestset "model interface" begin include("interfaces/model_interface.jl") end @@ -18,7 +15,4 @@ begin end # modules - @time @safetestset "particles types" begin - include("particle_types.jl") - end end