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)'
      
  • 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=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)   
      
  • The collision types are shown below:

particle_type

Amplitude_square() ——Scattering Matrix Element Calculation

The program focuses on the calculation of scattering matrix elements during 2-2 collisions.

Amplitude_square

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:

particle_type

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.

results matching ""

    No results matching ""