Question about simulation of signals from MWPC in Garfield++

[Timophey]

Hello everyone ! I’m trying to understand more deeply, how Garfield simulates the signals in gaseous detectors, so I working with MWPC detector and i have some questions about it:

1. What the difference between functions sensor.NewSignal() and sensor.ClearSignal() and when i should use them ?

2. When i trying to set signal (induced current) from external file (while testing the transfer functions) using function sensor.SetSignal(), the amplitude of the convoluted signal was much less, than than the program convoluted with the induced current, so where can i made a mistake ?

3. What is the difference between convolution methods with fast fourier transform and direct method ? I found out that convolution with FFT method is super fast for large signal files ( duration of my signal is 500 uS)

Code snippet(python) for question 2):

import ROOT
import Garfield
import matplotlib.pyplot as plt
import statistics
import numpy as np
from random import uniform

tmin = 0
tstep = 1
nTimeBins = 10000

volts_anode = 1530

raw_ion_signal - it is induced current (signal)
time_list - it is timebins

fm_closed = ROOT.Garfield.ComponentAnalyticField()

#---------------------------------Sensor for unipolar shaper------------------------------------------
sensor_unipolar_shaper = ROOT.Garfield.Sensor()
sensor_unipolar_shaper.AddComponent(fm_closed)
sensor_unipolar_shaper.AddElectrode(fm_closed, electrode)
sensor_unipolar_shaper.SetTimeWindow(tmin, tstep, nTimeBins)
sensor_unipolar_shaper.SetSignal(electrode, time_list, raw_ion_signal)

unipolar_shaper = ROOT.Garfield.Shaper(4, 163.6/4, 18.51, “unipolar”)
sensor_unipolar_shaper.SetTransferFunction(unipolar_shaper)

print(“Unipolar Shaper Transfer function Convolutting…”)
sensor_unipolar_shaper.ConvoluteSignal(electrode, True)
print(“End.\n”)

sampa_signal - it is convoluted signal calculated together with the induced current

unipol_signal = [sensor_unipolar_shaper.GetSignal(electrode, t) for t in range(tmin, nTimeBins, tstep)]

[hschindl]

Hi,
thanks a lot for your message!
(1) ClearSignal resets the signals stored for each electrode. If you want to simulate signal traces for individual tracks, this is what you should use. Sometimes it’s also useful to simulate the mean signal pulse (averaged over multiple tracks or events). When you call NewSignal, the signal will not be reset, but the Sensor increases the counter of the number of “events”. When you retrieve the signal, the accumulated signal will be divided by the number of “events”.

(2) That’s strange. I will try to reproduce the issue and do some digging.

(3) The default (direct) method does the convolution in the time domain. FFT is indeed typically faster. The only caveat is that you have to take care to avoid artefacts due to edge effects.

[Timophey]

hschindl, thanks a lot for a reply ! Also regarding the first question, i noticed that when i calculate the signal in the way of adding signal component (ion, electron and total) to the corresponding array after each avalanche iteration, the amplitude of final signal is higher (more by 2 orders of magnitude) that if didn’t do this adding (just simply plot signal after all avalanches). So if I want to preserve equal signal amplitudes, in first case i use sensor.NewSignal() after each avalanche, but if the signal “calculation” is after all avalanches (like in Examples) i don’t need to use that function. So why is this happening ? (the photos below is for the case of adding signal components to the arrays)

With sensor.NewSignal():

Withot sensor.NewSignal():

Code snippet for that case:

for i in range(n_electrons):

     aval.AvalancheElectron(x_0,y_0,z_0,t_0,e_0, d_x, d_y, d_z)
     for electron in aval.GetElectrons():
             p0 = electron.path[0]
             drift.DriftIon(p0.x,p0.y,p0.z,p0.t) #AvalancheMC object

     for t in range(tmin, nTimeBins, tstep):
                  total_s = sensor.GetSignal(electrode, t)
                  electron_s = sensor.GetElectronSignal(electrode, t)
                  ion_s = sensor.GetIonSignal(electrode, t)
                
                  e_signal_arr[t] += electron_s
                  i_signal_arr[t] += ion_s
                  tot_signal_arr[t] += total_s

     sensor.NewSignal()

[Timophey]

According for question 3):
So If I understand correctly the distortions of the signal doesn’t affects the results of convolution if I use the direct method, so therefore Garfield use this method as the default. And how can i recognize the distorted signal ?

[hschindl]

Hi,
sorry for the super-late reply! You should call NewSignal before simulating the electron avalanche and ion drift. In the snippet of code you posted, the “event counter” inside the Sensor object will be n_electrons + 1 after the for loop (instead of n_electrons).

[hschindl]

You should make sure that the signal is zero at the lower and upper limits of the time window you set (the FFT method works under the assumption that the signal is periodic). You could also take a typical signal in your application and compare what you get using the direct (time-domain) convolution and the FFT one to make sure.