Physics analysis into Particles Collision Energy

Introduction

Those who follow my steps in this social network, certainly know something about my Physics and Data Science projects. My main goal for the next year (maybe this year, actually) is to build a PINN (Physics Informed Neural Network) model for Hurricanes Forecasting.

I'm learning and studying a lot and actually have a solid physics model to valuate this problem. We also want to include a satellite images reanalysis and the statistic data to our model.

But before reach my goal, I'm practicing more about Physics Data Science. One of my favorite Physics Study field is Particles Physics. I was always fascinated by the large hadrons collider and since I've been working and developing into Data Science, I desired to build a analytical model to valuate those systems.

The Particles Collision Energy model

Step 1 - Downloading the database

For this project, I used a kaggle electron collision database, extracted from CERN.

You can reach the database here: https://www.kaggle.com/datasets/fedesoriano/cern-electron-collision-data

Step 2 - Importing the libraries

import pandas as pd

import numpy as np

import seaborn as sns

import matplotlib.pyplot as plt

For this analysis, I used pandas - to read my csv database file -, numpy for the matrix manipulations and seaborn/pyplot - to plot my histogram.

Step 3 - Reading my data and seeing how clean the data is

df = pd.read_csv(r'dielectron.csv'df.info())

The output shows me these info:

<class 'pandas.core.frame.DataFrame'>

RangeIndex: 100000 entries, 0 to 99999

Data columns (total 19 columns):

# Column Non-Null Count Dtype

--- ------ -------------- -----

0 Run 100000 non-null int64

1 Event 100000 non-null int64

2 E1 100000 non-null float64

3 px1 100000 non-null float64

4 py1 100000 non-null float64

5 pz1 100000 non-null float64

6 pt1 100000 non-null float64

7 eta1 100000 non-null float64

8 phi1 100000 non-null float64

9 Q1 100000 non-null int64

10 E2 100000 non-null float64

11 px2 100000 non-null float64

12 py2 100000 non-null float64

13 pz2 100000 non-null float64

14 pt2 100000 non-null float64

15 eta2 100000 non-null float64

16 phi2 100000 non-null float64

17 Q2 100000 non-null int64

18 M 99915 non-null float64

What gaves me a huge initial view of my dataframe. We can see that there are any null results and that the data type could be affordable to work. So, we can move on to select our interest data.

Step 4 - Stablishing our equations parameters

Following the reference book (An Introduction to Particle Physics and the Standard Model), one analytical physics solution for work with this dataframe is to use the Relativistic Mechanical Broadside Collision equation.

For a starting analysis, this worked, but in the future, I have to consider the charge influence in each particle.

With our database, we have the masses, the initial energies and our momentuns data for feed our model. We consider the lightspeed as 299792458m/s and used the transverse momentum* (already calculated and given in the dataframe) as our particular momentuns.

*The transverse momentum is the distribution of the hadron's quark or gluon momenta that are perpendicular to the momentum transfer between the beam and the hadron.

Here's the code:

TransversalMomentum1 = df['pt1] #Transversal Momentum of the first particle

TransversalMomentum1.to_numpy

TransversalMomentum2 = df['pt2'] #Transversal Momentum of the second particle

TransversalMomentum2.to_numpy

Energy1 = df['E1'] #Energy of the first particle in GeV

Energy1.to_numpy

Energy2 = df['E2'] #Energy of the second particle in GeV

Energy2.to_numpy

LightSpeed = 299792458 #Light speed in meters per second

MomentumVector1 = df[['px1 ', 'py1', 'pz1']] #Vectorial Momentum of the first particle

MomentumVector1 = MomentumVector1.to_numpy()

MomentumVector2 = df[['px2', 'py2', 'pz2']] #Vectorial Momentum of the second particle

MomentumVector2 = MomentumVector2.to_numpy()

Step 5 - Calculate the Collision Energy

Finally, we unite our parameters, with our chosen equation, in Python, as follows:

x = 0

DotProduct = []

while x < 100000:

? ? DotProduct.append(np.dot(MomentumVector1[x], MomentumVector2[x]))

? ? x+=1

df['CollisionEnergy'] = abs((np.power(TransversalMomentum1, 2) + np.power(TransversalMomentum1,2) + 2*((Energy1*Energy2/LightSpeed)) - (DotProduct))/1000)

We already united the results on the initial dataframe, adding a column named CollisionEnergy.

Step 6 - Statistics of my dataframe

Using some statistics function (maximum, minimum, mean and median), gave me a good view of how to build my histogram.

Here is the input code:

print('The maximum energy released in this dataset is: ', round(max(df['CollisionEnergy']),2), 'TeV.')

print('The minimum energy released in this dataset is: ', round(min(df['CollisionEnergy']),2), 'TeV.')

print('The mean of the energy values in this dataset is: ', round(np.mean(df['CollisionEnergy']),2), 'TeV.')

print('The median of the energy values in this dataset is: ', round(np.median(df['CollisionEnergy']),2), 'TeV.')

And here is my output statistical analysis:

The maximum energy released in this dataset is: 108.56 TeV.

The minimum energy released in this dataset is: 0.0 TeV.

The mean of the energy values in this dataset is: 1.25 TeV.

The median of the energy values in this dataset is: 0.55 TeV.

I choose to exclude the minimum and the distant maximum values. This was chosen after analyze the whole histogram and noticing that the number of events with an higher energy than 8TeV is low. I choose to exclude the 0 energy events, by analyzing some small events (later, I'll add the limit element in this case). With the median and mean data, we can conclude that the most part of energy collisions is less than 2TeV.

Step 7 - Visualizating the data

And after all, those are my results with this arcticle:

Mann, R. (2010). Chapter 2. In An introduction to particle physics and the standard model. essay, Taylor &amp; Francis.

The code line to plot the histogram is the next:

fig, ax = plt.subplots()

sns.set_style('darkgrid')

sns.histplot(df.CollisionEnergy, ax=ax, stat='count', element='poly')

ax.set_xlabel('Collision Energy (TeV)')

ax.set_ylabel('Number of events')

ax.set_xlim(0.01,8)

ax.set_xticks(range(0,9))

plt.show()

Step 8 - Conclusion

Analyzing the histogram, we can see that the concentration of events results in a Collision Energy between 0 and 2 TeV. What makes me consider to use another unit (GeV, for example).

This model could also be really improved in the future, by add the charge conditions.

References

Mann, R. (2010). Chapter 2. In An introduction to particle physics and the standard model. essay, Taylor &amp; Francis.

Any questions?

For more discussions or questions about this project, just call me and find the complete code on GitHub.

Author: Yan Barros