pyTT is a python code to simulate the temperature of thin targets when exposed to particle beams.
A target is usually considered thin, if the beam particles go through it losing only small amount of their energy.
However in this case thin refers rather to the fact that the energy deposition and the heat transfer
is in a relation which allows to neglect longitudinal dimension.
For instance a case where 4 MeV H- ions are stopped in 0.1 mm tungsten wire of
SEM detector can be considered as a thin target problem, assuming that longitudinal profile of the heating
(the energy is mostly deposited in the first half of the wire) can be neglected.
However the most common case for this kind of simulations is a case of particles
crossing the target and leaving uniform energy deposit along their track.
A good example are 1 GeV protons crossing 10-micrometer carbon fiber.
Currently the code performs only 1-D calculation so is adapted to cases of flying wires or SEM grids, however
its extension to 2-D problems (scintillation screens, stripping foils, etc) is planned.
The 1-D target is a wire. The simulation is discretized in time (Δt) and in the direction along the wire (Δy)
The model is described by the following equation:
The beam heating is described by the left side of the equation.
The first expression on the right side describes the heat capacity
of the target element (Δy). Further expressions describe the cooling processes:
- radiative cooling (second expression on the right side)
- conductive cooling (third expression)
- thermionic cooling (fourth expression plus fifth expression: reheating, not yet implemented)
- sublimation cooling (the last expression)
In addition sublimation process is estimated in course of the simulation
as well as the thermionic current, which is important for SEM-grid application.
The code was originally written (in 2008) as a root script, and a number of results were published.
The main document describing the code is: Model of carbon wire heating in accelerator beam
(CERN AB-2008-030-BI). In 2016 the code was translated to Python 2.7 and author runs it on linux machine, however some users run it
successfully on windows. The current code is upgraded to take into account not only Flying Wires but also SEM grids.
Configuration allows to setup simulation of circular machine and on linac. Project code is hosted on gitlab.
If you are interested in contributiong, let me know.
2021/Jun/22: Since about a year Araceli Navaro works on the code, converting it to python3, adding GUI and additional physics modules.
The code is hosted on github .
2023/Aug/01: Now the above version of the code, on gitlab, is the only
supported version.
An example of the simulation results are shown in Fig. 1, where temperature profiles during a scan of LHC beam
with 8e13 protons and with beam sigma=0.8 mm in the direction of scan and 0.53 mm in the transverse direction are shown.
The upper plot shows temperature profile along the wire at the end of the scan (blue curve) and radius of the wire.
In the center the radius is affected by the sublimation.
The bottom plot shows the temperature evolution of the wire center during the scan (blue curve) and the measured beam profile for
reference (green curve). The temperature rises to about 3000 K and stabilises due to high power removed by thermionic cooling.
The code version 2016.10.12.
Simulated cases
J-PARC Main Ring (MR) flying wire at injection:
beam:
- sigmax=8.9 mm
- sigmay=8.8 mm
- intensity = 3.5e13 protons
- energy = 3 GeV
- revolution period = 5 us
target:
- wire diameter = 7 um
- scan speed = 5 m/s
Results: maximum temperature about 1400 K, no sublimation. Interestingly the cooling is so slow that the maximum temperature
appears about 3 ms after crossing the beam center. The dE/dx is taken from PSTAR database so it does not include kick-off electrons
which significantly diminish the energy deposit.
CERN LHC wire scanner at injection (25% of nominal intensity):
beam:
- sigmax=0.8 mm
- sigmay=0.53 mm
- intensity = 8e13 protons
- energy = 450 GeV
- revolution period = 89 us
target:
- wire diameter = 33 um
- scan speed = 1 m/s
complete script:
sim_CERN_LHC_inj.py
Results: Temperature reaches and stabilises at 3500 K, which seems to be temperature at which thermionic emission
is able to cool down the wire very efficiently. It is also temperature at which sublimation starts playing a role.
This results disagree from 2008 paper (CERN AB-2008-030-BI) where cooling looked more efficient. This discrepancy is
being investigated.
J-PARC moving SEM-grid at the end of linac:
beam:
- sigmax=1.3 mm
- sigmay=1.5 mm
- intensity = 8e13 H-
- energy = 400 MeV
- pulse every 1 s
target:
- wire diameter = 100 um
- scan speed = 0.1 mm/pulse
complete script:
sim_JPARC_MWPM.py
Discussion: Conductive cooling is not simulated in this case.
Wires are gold-plated and gold melts in 1337 K. As the simulated temperatures reach almost 2500 K, the gold layer will melt.
In the middle of the beam the thermionic current reaches 10 uA.
GSI UNILAC standard SEM grid (with dev version of pyTT):
beam:
- sigmax=5 mm
- sigmay=1.5 mm
- intensity = 1e12 ions/pulse
- energy = 10 MeV
- pulse frequency: 50 Hz
target:
- wire diameter = 100 um
- wire material = tungsten
Results:
The wire reaches stable temperature of about 1050 K after about 6 s of the exposition to the beam.
|