Collision_database
The program primarily addresses collision types and scattering matrix element calculations in the QGP system and Fusion system.
To understand the background and principles of the application of the program you can refer to the following article
Towards a full solution of the relativistic Boltzmann equation for quark-gluon matter on GPUs
QGP system
Quark-Gluon Plasma is a phase state under quantum chromodynamics in an environment of very high temperature and density, with quarks and gluons present in the system.
Three collision scenarios are considered in the RGB-Maxwell program, 2-2 collisions, 2-3 collisions, and 3-2 collisions.
collision_type_for_all_species（）
- Main parameters in the program
- particle_order indexes the particles used in the collision calculation in order.
‘u (0), d (1), s (2), ubar (3), dbar (4), sbar (5), fluon (6)’
particle_order = 'u (0), d (1), s (2), ubar (3), dbar (4), sbar (5), fluon (6)'
- particle_order indexes the particles used in the collision calculation in order.
- Main parameters in the program
- flavor22
Three layers of data, with the first layer representing the seven particles, the second layer representing all collision types possible for that particle, and the third layer representing the 2-2 collision participating particle types
- flavor22
flavor22=np.array([[[0,0,0,0],[1,0,1,0],[2,0,2,0],[4,0,4,0],[5,0,5,0],[6,0,6,0], \
[3,0,3,0],[4,1,3,0],[5,2,3,0],[6,6,3,0]], \
[[0,1,0,1],[1,1,1,1],[2,1,2,1],[3,1,3,1],[5,1,5,1],[6,1,6,1], \
[4,1,4,1],[3,0,4,1],[5,2,4,1],[6,6,4,1]], \
[[0,2,0,2],[1,2,1,2],[2,2,2,2],[3,2,3,2],[4,2,4,2],[6,2,6,2], \
[5,2,5,2],[3,0,5,2],[4,1,5,2],[6,6,5,2]], \
[[1,3,1,3],[2,3,2,3],[3,3,3,3],[4,3,4,3],[5,3,5,3],[6,3,6,3], \
[0,3,0,3],[1,4,0,3],[2,5,0,3],[6,6,0,3]], \
[[0,4,0,4],[2,4,2,4],[3,4,3,4],[4,4,4,4],[5,4,5,4],[6,4,6,4], \
[1,4,1,4],[0,3,1,4],[2,5,1,4],[6,6,1,4]], \
[[0,5,0,5],[1,5,1,5],[3,5,3,5],[4,5,4,5],[5,5,5,5],[6,5,6,5], \
[2,5,2,5],[0,3,2,5],[1,4,2,5],[6,6,2,5]], \
[[0,6,0,6],[1,6,1,6],[2,6,2,6],[3,6,3,6],[4,6,4,6],[5,6,5,6], \
[6,6,6,6],[0,3,6,6],[1,4,6,6],[2,5,6,6]]],dtype=np.int32)
- Main parameters in the program
- collision_type22
Two layers of data, the first representing the seven particles and the second representing all the collision types that the particle may undergo
collision_type22=np.array([[1,0,0,0,0,5,2,3,3,4], \ [0,1,0,0,0,5,2,3,3,4], \ [0,0,1,0,0,5,2,3,3,4], \ [0,0,1,0,0,5,2,3,3,4], \ [0,0,0,1,0,5,2,3,3,4], \ [0,0,0,0,1,5,2,3,3,4], \ [5,5,5,5,5,5,6,4,4,4]],dtype=np.int32)
- collision_type22
- The collision types are shown below：
Amplitude_square() ——Scattering Matrix Element Calculation
The program focuses on the calculation of scattering matrix elements during 2-2 collisions.
def Amplitude_square(m1_squared,m2_squared,m3_squared,mp_squared,\
k10,k20,k30,p0,collision_type_indicator,\
k1x,k1y,k1z,k2x,k2y,k2z,k3x,k3y,k3z,px,py,pz,hbar,c,lambdax):
# change the values here
alpha_s = 0.3
dF = 3.
CA = 3.
CF = 4/3
dA = 8.
g = math.sqrt(4*math.pi*alpha_s)
mg_regulator_squared = 0.5**2
E1 = k10
E2 = k20
E3 = k30
Ep = p0
s = (E1+E2)**2-(k1x+k2x)**2-(k1y+k2y)**2-(k1z+k2z)**2
t = (E1-E3)**2-(k1x-k3x)**2-(k1y-k3y)**2-(k1z-k3z)**2
u = (E1-Ep)**2-(k1x-px)**2-(k1y-py)**2-(k1z-pz)**2
# spin and color averaged
# amplitude squared
if collision_type_indicator==0:
# q1+q2->q1+q2
return a_q1q2_q1q2(g,s,t,u,dF,CA,CF,dA,mg_regulator_squared)
elif collision_type_indicator==1:
# q+q->q+q
return a_qq_qq(g,s,t,u,dF,CA,CF,dA,mg_regulator_squared)
elif collision_type_indicator==2:
# q+q_bar -> q+q_bar
return a_qqbar_qqbar(g,s,t,u,dF,CA,CF,dA,mg_regulator_squared)
elif collision_type_indicator==3:
# q1+q1_bar -> q2+q2_bar
return a_q1q1bar_q2q2bar(g,s,t,u,dF,CA,CF,dA,mg_regulator_squared)
elif collision_type_indicator==4:
# q1+q1_bar -> gg
return a_q1q1bar_gg(g,s,t,u,dF,CA,CF,dA,mg_regulator_squared)
elif collision_type_indicator==5:
# q+g -> q+g
return a_qg_qg(g,s,t,u,dF,CA,CF,dA,mg_regulator_squared)
elif collision_type_indicator==6:
# gg -> gg
return a_gg_gg(g,s,t,u,dF,CA,CF,dA,mg_regulator_squared)
@cuda.jit(device=True)
def a_q1q2_q1q2(g,s,t,u,dF,CA,CF,dA,mg_regulator_squared):
return 8*(g**4)*(dF**2)*(CF**2)/dA*((s*s+u*u)/(t-mg_regulator_squared)**2)
@cuda.jit(device=True)
def a_qq_qq(g,s,t,u,dF,CA,CF,dA,mg_regulator_squared):
return 8*(g**4)*(dF**2)*(CF**2)/dA*((s*s+u*u)/((t-mg_regulator_squared)**2)+\
(s*s+t*t)/((u-mg_regulator_squared)**2))+\
16*(g**4)*dF*CF*(CF-CA/2)*(s*s)/((t-mg_regulator_squared)*(u-mg_regulator_squared))
@cuda.jit(device=True)
def a_qqbar_qqbar(g,s,t,u,dF,CA,CF,dA,mg_regulator_squared):
return 8*(g**4)*(dF**2)*(CF**2)/dA*((s*s+u*u)/((t-mg_regulator_squared)**2)+\
(u*u+t*t)/(s*s))+\
16*(g**4)*dF*CF*(CF-CA/2)*(u*u)/((t-mg_regulator_squared)*s)
@cuda.jit(device=True)
def a_q1q1bar_q2q2bar(g,s,t,u,dF,CA,CF,dA,mg_regulator_squared):
return 8*(g**4)*(dF**2)*(CF**2)/dA*((t*t+u*u)/(s*s))
@cuda.jit(device=True)
def a_q1q1bar_gg(g,s,t,u,dF,CA,CF,dA,mg_regulator_squared):
return 8*g**4*dF*CF**2*(u/(t-mg_regulator_squared)+t/(u-mg_regulator_squared))-\
8*g**4*dF*CF*CA*(t**2+u**2)/(s**2)
@cuda.jit(device=True)
def a_qg_qg(g,s,t,u,dF,CA,CF,dA,mg_regulator_squared):
return -8*g**4*dF*CF**2*(u/s+s/(u-mg_regulator_squared))+\
8*g**4*dF*CF*CA*(s*s+u*u)/((t-mg_regulator_squared)**2)
@cuda.jit(device=True)
def a_gg_gg(g,s,t,u,dF,CA,CF,dA,mg_regulator_squared):
return 16*g**4*dA*CA**2*(3-s*u/((t-mg_regulator_squared)**2)
-s*t/((u-mg_regulator_squared)**2)
-t*u/(s**2))
Fusion system
The Fusion system mainly contains H,H2,H2+,H+,e-, 5 kinds of particles.
Three collision scenarios are considered in the RGB-Maxwell framework, 2-2 collision, 2-3 collision, and 3-2 collision.
collision_type_for_all_species()
-
Main parameters in the program
-
particle_order indexes the particles used in the collision calculation in order.
‘u (0), d (1), s (2), ubar (3), dbar (4), sbar (5), fluon (6)’
particle_order = 'H+ (0), H2 (1), H (2), H2+ (3), e- (4)'- flavor[‘2TO2’]，flavor[‘2TO3’]，flavor[‘3TO2’]—-represent 2-2 collisions, 2-3 collisions, and 3-2 collisions respectively.
Three layers of data, with the first layer representing the seven particles, the second layer representing all collision types possible for that particle, and the third layer representing the 2-2 collision participating particle types, where 10001 represents null.
-
flavor['2TO2']=np.array([[[1,0,1,0], [10001,10001,10001,10001]],
[[0,1,0,1], [4,1,4,1]],
[[0,1,3,2], [10001,10001,10001,10001]],
[[0,1,2,3], [10001,10001,10001,10001]],
[[1,4,1,4], [10001,10001,10001,10001]]],dtype=np.int64)
flavor['2TO3']=np.array([[[0,1,3,4,0], [1,2,1,4,0], [10001,10001,10001,10001,10001], [10001,10001,10001,10001,10001]],
[[1,2,0,4,1], [10001,10001,10001,10001,10001], [10001,10001,10001,10001,10001], [10001,10001,10001,10001,10001]],
[[2,1,3,4,2], [10001,10001,10001,10001,10001], [10001,10001,10001,10001,10001], [10001,10001,10001,10001,10001]],
[[0,1,0,4,3], [1,2,2,4,3], [1,4,4,4,3], [10001,10001,10001,10001,10001]],
[[0,1,0,3,4], [1,2,0,1,4], [2,1,2,3,4], [1,4,3,4,4]]],dtype=np.int64)
- collision_type[‘2TO2’], collision_type[‘2TO3’], collision_type[‘3TO2’]—-represent 2-2 collisions, 2-3 collisions, and 3-2 collisions respectively.
Two layers of data, the first representing the seven particles and the second representing all the collision types that the particle may undergo, where 10001 represents null.
collision_type['2TO2']=np.array([[1,10001],[1,2],[0,10001],[0,10001],[2,10001]],dtype=np.int64)
collision_type['2TO3']=np.array([[0,1,10001,10001],\
[1,10001,10001,10001],\
[2,10001,10001,10001],\
[0,2,3,10001],\
[0,1,2,3]],dtype=np.int64)
- The collision types are shown below:
Amplitude_square() ——Scattering Matrix Element Calculation
The program focuses on the calculation of scattering matrix elements during 2-2, 2-3, and 3-2 collisions.
- 2-2 Collisions
@cuda.jit(device=True)
def Amplitude_square(m1_squared,m2_squared,m3_squared,mp_squared,\
k10,k20,k30,p0,collision_type_indicator,\
k1x,k1y,k1z,k2x,k2y,k2z,k3x,k3y,k3z,px,py,pz,hbar,c,lambdax):
s = m1_squared*c**2 + m2_squared*c**2 + 2*(k10*k20-k1x*k2x-k1y*k2y-k1z*k2z)
I = math.sqrt((k10*k20-k1x*k2x-k1y*k2y-k1z*k2z)**2-m1_squared*m2_squared*c**4)
# Only modify here
if collision_type_indicator==0:
return 10000.
elif collision_type_indicator==1:
return 10000.
elif collision_type_indicator==2:
return 10000.
else:
return 0.
- 2-3 Collisions
@cuda.jit(device=True)
def Amplitude_square(m1_squared,m2_squared,m3_squared,m4_squared,mp_squared,\
k10,k20,k30,k40,p0,collision_type_indicator,\
k1x,k1y,k1z,k2x,k2y,k2z,k3x,k3y,k3z,k4x,k4y,k4z,\
px,py,pz,hbar,c,lambdax):
s = m1_squared*c**2 + m2_squared*c**2 + 2*(k10*k20-k1x*k2x-k1y*k2y-k1z*k2z)
I = math.sqrt((k10*k20-k1x*k2x-k1y*k2y-k1z*k2z)**2-m1_squared*m2_squared*c**4)
# Only modify here
if collision_type_indicator==0:
return 10000.
elif collision_type_indicator==1:
return 10000.
elif collision_type_indicator==2:
return 10000.
elif collision_type_indicator==3:
return 10000.
else:
return 0.
- 3-2 Collisions
@cuda.jit(device=True)
def Amplitude_square(m1_squared,m2_squared,m3_squared,m4_squared,mp_squared,\
k10,k20,k30,k40,p0,collision_type_indicator,\
k1x,k1y,k1z,k2x,k2y,k2z,k3x,k3y,k3z,k4x,k4y,k4z,\
px,py,pz,hbar,c,lambdax):
s = m1_squared*c**2 + m2_squared*c**2 + 2*(k10*k20-k1x*k2x-k1y*k2y-k1z*k2z)
I = math.sqrt((k10*k20-k1x*k2x-k1y*k2y-k1z*k2z)**2-m1_squared*m2_squared*c**4)
# Only modify here
if collision_type_indicator==0:
return 10000.
elif collision_type_indicator==1:
return 10000.
elif collision_type_indicator==2:
return 10000.
elif collision_type_indicator==3:
return 10000.
else:
return 0.