Add support for simulation for dead layer-Step3: BulkSurfaceConstantLifetimeChargeTrappingModel #480

zpdg · 2025-04-21T19:31:14Z

Changes

Add a new charge trapping model:

Based on the constant lifetime for electron/hole
Parameters for the bulk (sensitive region) and surface (dead layer, or the inactive layer) volumes respectively

Test

The pulses while the hole lifetimes are 10 ns, 100 ns,,,1 ms. (the electron lifetime = 1ms)

Code for the test

using Revise
using Plots
using Pkg
Pkg.develop(path="./SolidStateDetectors.jl")
using SolidStateDetectors
using Unitful

T = Float32
sim = Simulation{T}(SSD_examples[:TrueCoaxial])
det_r=T(10/1000) # m
det_z=T(10/1000) # m
simulate!(sim)

bel = shl = sel = 1e6
plots=plot()
bhl_list = [10, 100, 1000, 10000, 100000, 1000000]
legend_name_list = ["10 ns", "100 ns", "1 µs", "10 µs", "100 µs", "1 ms"]
for (bhl,legend_name) in zip(bhl_list, legend_name_list)
    legend_name = "Hole lifetime = $(legend_name)"
    if_in_bulk = pos -> true
    parameters = Dict("parameters" => Dict("bhl" => bhl*u"ns", "bel" => bel*u"ns", "shl" => shl*u"ns", "sel" => sel*u"ns", "if_in_bulk" => if_in_bulk))
    trapping_model=BulkSurfaceConstantLifetimeChargeTrappingModel{T}(parameters)
    sim.detector = SolidStateDetector(sim.detector, trapping_model)

    energy_depos =[T(2.95/1000)] * u"keV"
    starting_positions = [CylindricalPoint{T}(det_r/2, deg2rad(0), det_z/2)]
    evt1 = Event(starting_positions, energy_depos);
    simulate!(evt1, sim, Δt = 1u"ns",max_nsteps=100)
    collected_charge=ustrip(maximum(evt1.waveforms[1].signal))
    plot!(evt1.waveforms[1], lw = 1.5, xlabel = "Time", ylabel = "Charge", 
                        unitformat = :slash, legend = true, label=legend_name, tickfontsize = 12, guidefontsize = 14,xlim=[0,100])
end
plots

zpdg · 2025-04-21T19:45:48Z

@fhagemann
Ah, sorry, seems the rebase doesn't work. I did the same thing as last time: git pull origin XXX --rebase. I thought it will work this time. Next time I will make sure it's in the right way.

…ifetimeChargeTrappingModel

fhagemann

In general, the struct BulkSurfaceConstantLifeTimeChargeTrappingModel is very long and I would avoid having a function if there if possible.
What about this:

Just having a ConstantLifeTimeChargeTrappingModel with electron and hole lifetime.
Define a virtual volume that defines "the surface" where you just apply another ConstantLifeTimeChargeTrappingModel

This way you don't need the function if_in_bulk and can have a simpler struct that is easier to deal with.

fhagemann · 2025-04-22T12:58:13Z

src/ChargeTrapping/ChargeTrapping.jl

+    if haskey(parameters, "bel")   bel =     _parse_value(T, parameters["bel"], internal_time_unit) end
+    if haskey(parameters, "shl")   shl =     _parse_value(T, parameters["shl"], internal_time_unit) end
+    if haskey(parameters, "sel")   sel =     _parse_value(T, parameters["sel"], internal_time_unit) end
+    if haskey(parameters, "if_in_bulk") if_in_bulk = parameters["if_in_bulk"] end


How do you envision defining this in a config file?
I expected parameters["if_in_bulk"] to be a String and to fail this line.

fhagemann · 2025-04-22T12:59:05Z

src/SolidStateDetector/Semiconductor.jl

@@ -85,6 +85,11 @@ function Semiconductor{T}(dict::AbstractDict, input_units::NamedTuple, outer_tra
                               haskey(dict["charge_trapping_model"], "model") &&
                               dict["charge_trapping_model"]["model"] == "Boggs"
        BoggsChargeTrappingModel{T}(dict["charge_trapping_model"], temperature = temperature)
+    # TODO: implementation method of the BulkSurfaceConstantLifetimeChargeTrappingModel using the Configuration file


Ah I see, this is still WIP. Do you plan to do this in this PR?

The only problem is we need the the is_in_bulk function, which is tricky to implement in the config. I am gonna try first, using the virtual volume.

fhagemann · 2025-04-22T13:00:16Z

test/test_charge_drift_models.jl

@@ -80,6 +80,21 @@ end

    end
 end
+@timed_testset "Charge Trapping: BulkSurfaceConstantLifetimeChargeTrappingModel" begin
+    bhl = bel = shl = sel = 0.1 # 0.1 ms -> signalsum: ~1.9778; 0.01 -> ~1.8029; 1 -> ~1.9963


If you know what the values are, you could test for exactly this: test lifetimes getting shorter and shorter and testing that the signal sum decreases

Yes, I will add a few more tests.

fhagemann · 2025-04-22T13:03:19Z

src/ChargeTrapping/ChargeTrapping.jl

+    bel::T
+    shl::T
+    sel::T
+    if_in_bulk::Function


Shouldn't this be is_in_bulk?

Ah, yes, is_in_bulk is more in line with the other function names. I will change this.

fhagemann · 2025-04-22T13:04:13Z

src/ChargeTrapping/ChargeTrapping.jl

+
+    @inbounds for i in eachindex(tmp_signal)
+        Δt::T = (i > 1) ? (pathtimestamps[i] - pathtimestamps[i-1]) : zero(T)
+        Δq::T = ctm.if_in_bulk(path[i]) ? q * Δt/bl : q * Δt/sl


What if Δt is bigger than bl and sl ? Then, you will flip the sign of the charge.

Yes, that is a potential breaking. But the bl and sl are much bigger than 100 ns in most of the cases, while we usually set the Δt to 1 ns.

I think we should add a reminder that the Δt should be much smaller than bl and sl.

fhagemann · 2025-04-22T13:05:46Z

src/ChargeTrapping/ChargeTrapping.jl

+
+    parameters = haskey(config_dict, "parameters") ? config_dict["parameters"] : config_dict
+
+    allowed_keys = ("bhl", "bel", "shl", "sel", "if_in_bulk")


Maybe the keywords should be a bit more descriptive than this?
sel to me sound rather like selection rather than the abbreviation of surface electron lifetime.
Maybe use τ (τh and τe)?

Yes, use the symbol is better.

zpdg · 2025-04-22T15:01:16Z

In general, the struct BulkSurfaceConstantLifeTimeChargeTrappingModel is very long and I would avoid having a function if there if possible. What about this:

Just having a ConstantLifeTimeChargeTrappingModel with electron and hole lifetime.

Define a virtual volume that defines "the surface" where you just apply another ConstantLifeTimeChargeTrappingModel

This way you don't need the function if_in_bulk and can have a simpler struct that is easier to deal with.

Sounds better. I will look into this virtual volume way.

…within cofig) 2) use symbol 3) more test

zpdg · 2025-04-24T13:24:18Z

@fhagemann
Now, we could define the inactive layer in the configuration fire under the charge_trapping_model field with the field name inactive_layer_geometry, and pass the geometry to the trapping model in the semiconductor.jl. And I've made the inactive layer feature optional.

I didn't choose to use the VirtualVolumes. Because we would need to pass the virtual volumes geometry to the trapping model, which means much more modification.

fhagemann · 2025-04-28T09:37:56Z

docs/src/man/charge_drift.md

+# only model the sensitive volume
+τh = τe = 1e6
+parameters = Dict("parameters" => Dict("τh" => τh*u"ns", "τe" => τe*u"ns"))


Suggested change

# only model the sensitive volume

τh = τe = 1e6

parameters = Dict("parameters" => Dict("τh" => τh*u"ns", "τe" => τe*u"ns"))

# only model the sensitive volume

τh = τe = 1e6*u"ns"

parameters = Dict("parameters" => Dict("τh" => τh, "τe" => τe))

Or maybe even do τh = τe = 1u"ms" if that also works

fhagemann · 2025-04-28T09:39:35Z

docs/src/man/charge_drift.md

+τh = τe = 1e6
+τh_inactive = τe_inactive = 80
+parameters = Dict("parameters" => Dict("τh" => τh*u"ns", "τe" => τe*u"ns", "τh_inactive" => τh_inactive*u"ns", "τe_inactive" => τe_inactive*u"ns"), "inactive_layer_geometry" => sim.detector.semiconductor.charge_trapping_model.inactive_layer_geometry)


Apply the units already to τh etc.:

Suggested change

τh = τe = 1e6

τh_inactive = τe_inactive = 80

parameters = Dict("parameters" => Dict("τh" => τh*u"ns", "τe" => τe*u"ns", "τh_inactive" => τh_inactive*u"ns", "τe_inactive" => τe_inactive*u"ns"), "inactive_layer_geometry" => sim.detector.semiconductor.charge_trapping_model.inactive_layer_geometry)

τh = τe = 1e6u"ns"

τh_inactive = τe_inactive = 80u"ns"

parameters = Dict("parameters" => Dict("τh" => τh, "τe" => τe, "τh_inactive" => τh_inactive, "τe_inactive" => τe_inactive), "inactive_layer_geometry" => sim.detector.semiconductor.charge_trapping_model.inactive_layer_geometry)

src/ChargeTrapping/ChargeTrapping.jl

fhagemann · 2025-04-28T09:42:13Z

src/ChargeTrapping/ChargeTrapping.jl

+"""
+    struct ConstantLifetimeChargeTrappingModel{T <: SSDFloat} <: AbstractChargeTrappingModel{T}
+        
+This constant-lifetime-based charge trapping model is similar to the Boggs model, which is constant-mean-free-path based.


Maybe define this without referencing Boggs here, something like

Suggested change

This constant-lifetime-based charge trapping model is similar to the Boggs model, which is constant-mean-free-path based.

This constant-lifetime-based charge trapping model assumes electrons and holes to have a constant free lifetime throughout the crystal.

fhagemann · 2025-04-28T09:42:48Z

src/ChargeTrapping/ChargeTrapping.jl

+This constant-lifetime-based charge trapping model is similar to the Boggs model, which is constant-mean-free-path based.
+
+The model implemented has two sets of parameters for the sensitive (bulk) and inactive (dead layer/surface layer) volume respectively.
+The inactive layer effect will only be considered if the corresponding `virtual_drift_volume` is defined in the configuration file.


Is it a virtual_drift_volume? You call it inactive_layer_geometry in the documentation.

fhagemann · 2025-04-28T09:45:52Z

src/ChargeTrapping/ChargeTrapping.jl

+    running_sum::T = zero(T)
+    q::T = charge
+
+    inactive_layer_exist = ctm.inactive_layer_geometry !== missing


Suggested change

inactive_layer_exist = ctm.inactive_layer_geometry !== missing

inactive_layer_exist = !ismissing(ctm.inactive_layer_geometry)

Again, consider using nothing as default, you can then use !isnothing here.

fhagemann · 2025-04-28T09:47:49Z

src/ChargeTrapping/ChargeTrapping.jl

+
+    @inbounds for i in eachindex(tmp_signal)
+        Δt::T = (i > 1) ? (pathtimestamps[i] - pathtimestamps[i-1]) : zero(T)
+        Δq::T = (inactive_layer_exist && in(path[i], ctm.inactive_layer_geometry)) ? q * Δt/τ_inactive : q * Δt/τ


Split this into two lines so it's easier to see what is happening:

Suggested change

Δq::T = (inactive_layer_exist && in(path[i], ctm.inactive_layer_geometry)) ? q * Δt/τ_inactive : q * Δt/τ

τi::T = (inactive_layer_exist && in(path[i], ctm.inactive_layer_geometry)) ? τ_inactive : τ

Δq::T = q * Δt/τi

fhagemann · 2025-04-28T09:51:26Z

src/ChargeTrapping/ChargeTrapping.jl

+    end
+
+    parameters = haskey(config_dict, "parameters") ? config_dict["parameters"] : config_dict
+    inactive_layer_geometry = haskey(config_dict, "inactive_layer_geometry") ? config_dict["inactive_layer_geometry"] : missing


Consider using nothing here as default.

fhagemann · 2025-04-28T09:51:58Z

src/ChargeTrapping/ChargeTrapping.jl

+    end
+
+    parameters = haskey(config_dict, "parameters") ? config_dict["parameters"] : config_dict
+    inactive_layer_geometry = haskey(config_dict, "inactive_layer_geometry") ? config_dict["inactive_layer_geometry"] : missing


Consider using nothing here as default.

Suggested change

inactive_layer_geometry = haskey(config_dict, "inactive_layer_geometry") ? config_dict["inactive_layer_geometry"] : missing

inactive_layer_geometry = haskey(config_dict, "inactive_layer_geometry") ? config_dict["inactive_layer_geometry"] : nothing

test/test_charge_drift_models.jl

fhagemann · 2025-04-28T09:56:42Z

Code for the test

using Revise
using Plots
using Pkg
Pkg.develop(path="./SolidStateDetectors.jl")
using SolidStateDetectors
using Unitful

T = Float32
sim = Simulation{T}(SSD_examples[:TrueCoaxial])
det_r=T(10/1000) # m
det_z=T(10/1000) # m
simulate!(sim)

bel = shl = sel = 1e6
plots=plot()
bhl_list = [10, 100, 1000, 10000, 100000, 1000000]
legend_name_list = ["10 ns", "100 ns", "1 µs", "10 µs", "100 µs", "1 ms"]
for (bhl,legend_name) in zip(bhl_list, legend_name_list)
    legend_name = "Hole lifetime = $(legend_name)"
    if_in_bulk = pos -> true
    parameters = Dict("parameters" => Dict("bhl" => bhl*u"ns", "bel" => bel*u"ns", "shl" => shl*u"ns", "sel" => sel*u"ns", "if_in_bulk" => if_in_bulk))
    trapping_model=BulkSurfaceConstantLifetimeChargeTrappingModel{T}(parameters)
    sim.detector = SolidStateDetector(sim.detector, trapping_model)

    energy_depos =[T(2.95/1000)] * u"keV"
    starting_positions = [CylindricalPoint{T}(det_r/2, deg2rad(0), det_z/2)]
    evt1 = Event(starting_positions, energy_depos);
    simulate!(evt1, sim, Δt = 1u"ns",max_nsteps=100)
    collected_charge=ustrip(maximum(evt1.waveforms[1].signal))
    plot!(evt1.waveforms[1], lw = 1.5, xlabel = "Time", ylabel = "Charge", 
                        unitformat = :slash, legend = true, label=legend_name, tickfontsize = 12, guidefontsize = 14,xlim=[0,100])
end
plots

Once this PR is finished, could you update the test code to work with the new implementation/naming? :)

zpdg · 2025-04-28T16:56:55Z

Code for the test

using Revise
using Plots
using Pkg
Pkg.develop(path="./SolidStateDetectors.jl")
using SolidStateDetectors
using Unitful

T = Float32
sim = Simulation{T}(SSD_examples[:TrueCoaxial])
det_r=T(10/1000) # m
det_z=T(10/1000) # m
simulate!(sim)

bel = shl = sel = 1e6
plots=plot()
bhl_list = [10, 100, 1000, 10000, 100000, 1000000]
legend_name_list = ["10 ns", "100 ns", "1 µs", "10 µs", "100 µs", "1 ms"]
for (bhl,legend_name) in zip(bhl_list, legend_name_list)
    legend_name = "Hole lifetime = $(legend_name)"
    if_in_bulk = pos -> true
    parameters = Dict("parameters" => Dict("bhl" => bhl*u"ns", "bel" => bel*u"ns", "shl" => shl*u"ns", "sel" => sel*u"ns", "if_in_bulk" => if_in_bulk))
    trapping_model=BulkSurfaceConstantLifetimeChargeTrappingModel{T}(parameters)
    sim.detector = SolidStateDetector(sim.detector, trapping_model)

    energy_depos =[T(2.95/1000)] * u"keV"
    starting_positions = [CylindricalPoint{T}(det_r/2, deg2rad(0), det_z/2)]
    evt1 = Event(starting_positions, energy_depos);
    simulate!(evt1, sim, Δt = 1u"ns",max_nsteps=100)
    collected_charge=ustrip(maximum(evt1.waveforms[1].signal))
    plot!(evt1.waveforms[1], lw = 1.5, xlabel = "Time", ylabel = "Charge", 
                        unitformat = :slash, legend = true, label=legend_name, tickfontsize = 12, guidefontsize = 14,xlim=[0,100])
end
plots

Once this PR is finished, could you update the test code to work with the new implementation/naming? :)

Sure! I will update all the naming and the test code tomorrow.

zpdg · 2025-04-29T18:14:41Z

Updated test code for this PR:

using Revise
using Plots
using Pkg
Pkg.develop(path="./SolidStateDetectors.jl")
using SolidStateDetectors
using Unitful
T = Float32
sim = Simulation{T}(SSD_examples[:TrueCoaxial])
simulate!(sim)

plots = plot()
τe = 1u"ms"
τh_list = (10u"ns", 100u"ns", 1u"µs", 10u"µs", 100u"µs", 1u"ms")
for τh in τh_list
    trapping_model = ConstantLifetimeChargeTrappingModel{T}(Dict("parameters" => Dict("τh" => τh, "τe" => τe)))
    sim.detector = SolidStateDetector(sim.detector, trapping_model)
    energy_depos = [sim.detector.semiconductor.material.E_ionisation]
    starting_positions = [CylindricalPoint{T}(0.005, 0, 0.005)]
    evt = Event(starting_positions, energy_depos)
    simulate!(evt, sim, Δt=1u"ns", max_nsteps=100)
    plot!(evt.waveforms[1], xlabel="Time", ylabel="Charge", label="Hole lifetime = $(τh)", xlim=[0, 100])
end
plots

fhagemann · 2025-05-05T07:18:13Z

test/test_charge_drift_models.jl

+    config_dict = SolidStateDetectors.parse_config_file(SSD_examples[:TrueCoaxial])
+    simA = @test_nowarn Simulation{T}(config_dict)


You don't seem to use config_dict anywhere else, so you could just do

Suggested change

config_dict = SolidStateDetectors.parse_config_file(SSD_examples[:TrueCoaxial])

simA = @test_nowarn Simulation{T}(config_dict)

simA = @test_nowarn Simulation{T}(SSD_examples[:TrueCoaxial])

fhagemann · 2025-05-05T07:18:31Z

test/test_charge_drift_models.jl

+        @test simA.detector.semiconductor.charge_trapping_model.inactive_layer_geometry.hZ == T(0.005)
+    end
+
+    simA = Simulation{T}(SSD_examples[:TrueCoaxial])


Then you can also skip this line and continue using simA from line 86

fhagemann · 2025-05-05T07:19:24Z

test/test_charge_drift_models.jl

+    simA_inactive_layer_geometry=deepcopy(simA.detector.semiconductor.charge_trapping_model.inactive_layer_geometry)
+
+    # test2: only model the bulk volume, test the bulk signals while varying the lifetime: τ
+    pos = CartesianPoint{T}(0.005,0,0.005); Edep = 1u"eV"
    signalsum_list = []


In general, if you create an Array to push! to it afterwards, consider specifying a type

Suggested change

signalsum_list = []

signalsum_list = T[]

fhagemann · 2025-05-05T07:20:04Z

test/test_charge_drift_models.jl

+    pos_bulk = CartesianPoint{T}(0.0085,0,0.005); Edep = 1u"eV"
+    @test !in(pos_bulk, simA_inactive_layer_geometry)
+    signalsum_list_bulk = []
+    τ_list = (10 .^ (-2:0.2:0))*u"ms"
+    pos_inactive = CartesianPoint{T}(0.0095,0,0.005); Edep = 1u"eV"
+    @test in(pos_inactive, simA_inactive_layer_geometry)
+    signalsum_list_inactive = []


Same thing here:

Suggested change

pos_bulk = CartesianPoint{T}(0.0085,0,0.005); Edep = 1u"eV"

@test !in(pos_bulk, simA_inactive_layer_geometry)

signalsum_list_bulk = []

τ_list = (10 .^ (-2:0.2:0))*u"ms"

pos_inactive = CartesianPoint{T}(0.0095,0,0.005); Edep = 1u"eV"

@test in(pos_inactive, simA_inactive_layer_geometry)

signalsum_list_inactive = []

pos_bulk = CartesianPoint{T}(0.0085,0,0.005); Edep = 1u"eV"

@test !in(pos_bulk, simA_inactive_layer_geometry)

signalsum_list_bulk = T[]

τ_list = (10 .^ (-2:0.2:0))*u"ms"

pos_inactive = CartesianPoint{T}(0.0095,0,0.005); Edep = 1u"eV"

@test in(pos_inactive, simA_inactive_layer_geometry)

signalsum_list_inactive = T[]

fhagemann · 2025-05-05T07:20:57Z

test/test_charge_drift_models.jl

+    @info signalsum_list_bulk
+    @test all(signalsum_list_bulk .< T(2.0))
+    @test all(diff(signalsum_list_bulk) .> 0)
+    @info signalsum_list_inactive
+    @test all(signalsum_list_inactive .< T(2.0))
+    @test all(diff(signalsum_list_inactive) .> 0)
+    @test all(signalsum_list_bulk .> signalsum_list_inactive)


Maybe remove the @info statements for the tests

Suggested change

@info signalsum_list_bulk

@test all(signalsum_list_bulk .< T(2.0))

@test all(diff(signalsum_list_bulk) .> 0)

@info signalsum_list_inactive

@test all(signalsum_list_inactive .< T(2.0))

@test all(diff(signalsum_list_inactive) .> 0)

@test all(signalsum_list_bulk .> signalsum_list_inactive)

@test all(signalsum_list_bulk .< T(2.0))

@test all(diff(signalsum_list_bulk) .> 0)

@test all(signalsum_list_inactive .< T(2.0))

@test all(diff(signalsum_list_inactive) .> 0)

@test all(signalsum_list_bulk .> signalsum_list_inactive)

fhagemann · 2025-05-05T07:21:40Z

test/test_charge_drift_models.jl

+        pos_inactive = CartesianPoint{T}(0.01-depth,0,0.005); Edep = 1u"eV"
+        @test in(pos_inactive, simA_inactive_layer_geometry)
+        evt_inactive = Event(pos_inactive , Edep)
+        timed_simulate!(evt_inactive, simA, diffusion=false, Δt=1u"ns")


No need to have explicit diffusion = false, this is the default

Suggested change

timed_simulate!(evt_inactive, simA, diffusion=false, Δt=1u"ns")

timed_simulate!(evt_inactive, simA, Δt=1u"ns")

fhagemann · 2025-05-05T07:21:57Z

test/test_charge_drift_models.jl

+        "inactive_layer_geometry" => simA_inactive_layer_geometry)
+    trapping_model=ConstantLifetimeChargeTrappingModel{T}(parameters)
+    simA.detector = SolidStateDetector(simA.detector, trapping_model)
+    signalsum_list_inactive = []


Suggested change

signalsum_list_inactive = []

signalsum_list_inactive = T[]

fhagemann · 2025-05-05T07:23:49Z

docs/src/man/charge_drift.md

+              z: 5.0
+```
+
+The inactive layer could only be modeled with the help of the configuration file.


Is that still true? I saw in the tests that you can pass a geometry as inactive_layer to create a new SolidStateDetector

Yes, we can pass the geometry without the config, but the geometry has to be defined in the config.

fhagemann · 2025-05-05T07:24:17Z

docs/src/man/charge_drift.md

+# model both the sensitive and inactive volumes based on the inactive volume geometry defined in the configuration file
+τh = τe = 1u"ms"
+τh_inactive = τe_inactive = 80u"ns"
+parameters = Dict("parameters" => Dict("τh" => τh, "τe" => τe, "τh_inactive" => τh_inactive, "τe_inactive" => τe_inactive), "inactive_layer_geometry" => sim.detector.semiconductor.charge_trapping_model.inactive_layer_geometry)
+
+sim.detector = SolidStateDetector(sim.detector, ConstantLifetimeChargeTrappingModel{T}(parameters))


Also here, it looks like you can pass a geometry, even without using a configuration file.

fhagemann · 2025-05-05T07:26:09Z

src/ChargeTrapping/ChargeTrapping.jl

+* `τh_inactive::T`: Lifetime for holes in surface layer (dead layer/inactive layer) (default: `τh_inactive = 1ms`).
+* `τe_inactive::T`: Lifetime for electrons in surface layer (default: `τe_inactive = 1ms`).
+* `inactive_layer_geometry`: The geometry of the inactive layer. When this is defined, the model will consider the inactive effect.
+> Note: All τ must be much bigger than `Δt`.


Do you explicitly check for this in the drift code? If not, it might make sense to throw a warning or error if τ is smaller than Δt.

Yes, it works like expected when τ is bigger than 10 ns, and it doesn't work when τ is 1 ns. I didn't test more values, but it already makes a lot of sense. When solving the difference equation, you should always make sure the step is small enough. But it is indeed better to throw a warning when τ and Δt are close.

Actually, the Boggs model also has this problem. The parameter (mean free path) should also be much bigger than the typical step length.

fhagemann · 2025-05-05T07:27:26Z

src/ChargeTrapping/ChargeTrapping.jl

+    inactive_layer_exist = !isnothing(ctm.inactive_layer_geometry)
+    τ::T = ifelse(charge > 0, ctm.τh, ctm.τe)
+    τ_inactive::T = ifelse(charge > 0, ctm.τh_inactive, ctm.τe_inactive)
+


Add a check here to see that τ is bigger than Δt?

fhagemann · 2025-05-05T07:31:19Z

src/ChargeTrapping/ChargeTrapping.jl

+function ConstantLifetimeChargeTrappingModel{T}(config_dict::AbstractDict = Dict()) where {T <: SSDFloat}
+    τh::T = ustrip(u"s", 1u"ms")
+    τe::T = ustrip(u"s", 1u"ms")
+    τh_inactive::T = ustrip(u"s", 80u"ns")
+    τe_inactive::T = ustrip(u"s", 80u"ns")
+
+    if haskey(config_dict, "model") && !haskey(config_dict, "parameters")
+        throw(ConfigFileError("`ConstantLifetimeChargeTrappingModel` does not have `parameters`"))
+    end
+
+    parameters = haskey(config_dict, "parameters") ? config_dict["parameters"] : config_dict
+    inactive_layer_geometry = haskey(config_dict, "inactive_layer_geometry") ? config_dict["inactive_layer_geometry"] : nothing
+
+    allowed_keys = ("τh", "τe", "τh_inactive", "τe_inactive")
+    k = filter(k -> !(k in allowed_keys), keys(parameters))
+    !isempty(k) && @warn "The following keys will be ignored: $(k).\nAllowed keys are: $(allowed_keys)"
+
+    if haskey(parameters, "τh")   τh =     _parse_value(T, parameters["τh"], internal_time_unit) end
+    if haskey(parameters, "τe")   τe =     _parse_value(T, parameters["τe"], internal_time_unit) end
+    if haskey(parameters, "τh_inactive")   τh_inactive =     _parse_value(T, parameters["τh_inactive"], internal_time_unit) end
+    if haskey(parameters, "τe_inactive")   τe_inactive =     _parse_value(T, parameters["τe_inactive"], internal_time_unit) end
+    ConstantLifetimeChargeTrappingModel{T, typeof(inactive_layer_geometry)}(τh, τe, τh_inactive, τe_inactive, inactive_layer_geometry)
+end


Is it already possible to define the model something like this?

charge_trapping_model = Dict( "model" => Dict( "τh" => 1u"ms", "τe" => 1u"ms", "τh_inactive" => 80u"ns", "τe_inactive" => 80u"ns" ), "inactive_layer_geometry" => Dict( "tube" => Dict( "r" => Dict("from" => 9.0u"mm", "to" => 10.0u"mm"), "h" => 10.0u"mm", "origin" => Dict("z" => 5.0u"mm") ) ) )

or can inactive_layer_geometry only be a Geometry object (or nothing)?

Ah, yes! This seems to be a way to define the full trapping model without the config. I will try to build the geometry with a dict in the trapping model struct.

fhagemann · 2025-05-05T07:32:33Z

src/SolidStateDetector/Semiconductor.jl

+        if haskey(constant_lifetime_ctm_dict, "inactive_layer_geometry")
+            constant_lifetime_ctm_dict["inactive_layer_geometry"] = Geometry(T, dict["charge_trapping_model"]["inactive_layer_geometry"], input_units, transformations)
+        end


Maybe something like this could be added to the constructor of ConstantLifetimeChargeTrappingModel?

zpdg changed the title ~~Constant lifetime trapping model~~ Add support for simulation for dead layer-Step3: BulkSurfaceConstantLifetimeChargeTrappingModel Apr 21, 2025

zpdg added 2 commits April 22, 2025 14:55

Add support for simulation for dead layer-Step3: BulkSurfaceConstantL…

dba0ce8

…ifetimeChargeTrappingModel

Fix the problem: the short doi failed the github check

b8bfdee

fhagemann force-pushed the ConstantLifetimeTrappingModel branch from ff8fb10 to b8bfdee Compare April 22, 2025 12:55

fhagemann reviewed Apr 22, 2025

View reviewed changes

1) Support for modeling with config (define inactive volume geometry …

d158867

…within cofig) 2) use symbol 3) more test

Fix a typo

dc592cf

fhagemann reviewed Apr 28, 2025

View reviewed changes

zpdg added 2 commits April 29, 2025 20:06

Clearer naming

35c6a7f

Clearer naming

7c02713

Add test for inactive layer

9f276f4

fhagemann reviewed May 5, 2025

View reviewed changes


		parameters = haskey(config_dict, "parameters") ? config_dict["parameters"] : config_dict

		allowed_keys = ("bhl", "bel", "shl", "sel", "if_in_bulk")

	This constant-lifetime-based charge trapping model is similar to the Boggs model, which is constant-mean-free-path based.
	This constant-lifetime-based charge trapping model assumes electrons and holes to have a constant free lifetime throughout the crystal.

	inactive_layer_exist = ctm.inactive_layer_geometry !== missing
	inactive_layer_exist = !ismissing(ctm.inactive_layer_geometry)

	Δq::T = (inactive_layer_exist && in(path[i], ctm.inactive_layer_geometry)) ? q * Δt/τ_inactive : q * Δt/τ
	τi::T = (inactive_layer_exist && in(path[i], ctm.inactive_layer_geometry)) ? τ_inactive : τ
	Δq::T = q * Δt/τi

	inactive_layer_geometry = haskey(config_dict, "inactive_layer_geometry") ? config_dict["inactive_layer_geometry"] : missing
	inactive_layer_geometry = haskey(config_dict, "inactive_layer_geometry") ? config_dict["inactive_layer_geometry"] : nothing

		config_dict = SolidStateDetectors.parse_config_file(SSD_examples[:TrueCoaxial])
		simA = @test_nowarn Simulation{T}(config_dict)

	config_dict = SolidStateDetectors.parse_config_file(SSD_examples[:TrueCoaxial])
	simA = @test_nowarn Simulation{T}(config_dict)
	simA = @test_nowarn Simulation{T}(SSD_examples[:TrueCoaxial])

	timed_simulate!(evt_inactive, simA, diffusion=false, Δt=1u"ns")
	timed_simulate!(evt_inactive, simA, Δt=1u"ns")

Add support for simulation for dead layer-Step3: BulkSurfaceConstantLifetimeChargeTrappingModel #480

Are you sure you want to change the base?

Add support for simulation for dead layer-Step3: BulkSurfaceConstantLifetimeChargeTrappingModel #480

Conversation

zpdg commented Apr 21, 2025

Changes

Test

Code for the test

zpdg commented Apr 21, 2025

fhagemann left a comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

zpdg Apr 22, 2025 • edited Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

zpdg commented Apr 22, 2025

zpdg commented Apr 24, 2025 • edited Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

fhagemann commented Apr 28, 2025

Code for the test

zpdg commented Apr 28, 2025

Code for the test

zpdg commented Apr 29, 2025

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

zpdg Apr 22, 2025 •

edited

Loading

zpdg commented Apr 24, 2025 •

edited

Loading