structures: Input and Algorithm objects. Products of the first kind are created by
the Pandora application before running the reconstruction algorithms and cannot
be changed by them. On the other hand, the Algorithm objects are created and
modified by reconstruction algorithms.

The Pandora SDK implements three kinds of Input Objects.
CaloHit: represents a space point deposition in the detector and is the
fundamental building block of the Pandora event representation. Each CaloHit is
associated with the $x$, $y$, $z$ detector coordinates and the relative deposited
energy $E$. Within a LArTPC a CaloHit is built from processed raw signals of the
form discussed in chapter <ref>: a single peak in an ROI region is
fitted with $N$ multiple Gaussians to allow the possibility to have
several single depositions within a single peak. Each fitted gaussian in the peak
is turned as a separate CaloHit. LArTPC raw data are described by a drift
coordinate ($x$ coordinate) and a readout channel number identifier, indeed,
Pandora CaloHits are initially given a null $y$ component and a $z$ component
referring to the position of the wire where the signal was first detected in the
wire pitch direction. The transformation from the wire plane representation to
the canonical detector $3{-}$dimensional cartesian coordinate system involves a
rotation-like operation that requires at least two wire plane coordinates to be
known for each CaloHit. An additional flag for each CaloHit signals which of the
$3$ different wire planes ($\mathrm{U}$, $\mathrm{V}$ or $\mathrm{W}$) recorded
the corresponding signal.

Track: represents a collection of CaloHits objects arranged in a
continuous pattern. Beyond the CaloHits and their attributes belonging to the
Track object, this holds other global information like associated particle
momentum and trajectory direction. The Track object can also have methods to
retrieve the parent, daughter and sibling relationships with other Tracks with
the intent to build a particle tree to describe the interaction hierarchy
contained in the event.

MCParticle: is an object collecting true information from simulation (of
course, detector data do not hold this kind of details) about an event particle.
This kind of data structure is carried within Pandora mostly for development
reasons, as it allows to cheat parts or even entire algorithms in the
reconstruction workflow. It can also be used to measure performance metrics for
the tools' implementations. The key idea is that the best method should reproduce
as much as possible the true information contained in the MCParticle objects and
the related MCParticleLists.

The Pandora framework implements also Algorithm objects: auxiliary products that
represent outputs at various steps of the reconstruction process. Below we
introduce the most important ones.

Cluster: represents a collection of CaloHits carrying space and energy
information. It also usually contains estimations of Cluster global properties,
such as results of energy or geometrical fits. Being an Algorithm object, Pandora
implements also operations that allow the algorithms to create, read, split and
merge different Cluster objects.

Vertex: this object might not correspond to a true CaloHit
deposition, but it is rather the output of a fitting procedure on the available
event CaloHits. It identifies the exact space point where an interaction took place
during the readout window. It naturally holds also information about the particle
involved in the interaction, highlighting the parent-daughter structure of the
physical scattering.

ParticleFlowObject (PFO): this can be seen as the final reconstruction
output. It is a class containing all the information gathered through several
algorithms about an event particle. A PFO instance is linked with all the
information that a physics analysis might desire to investigate: as such, it is
associated with Clusters, Tracks and Vertices objects belonging to the particle
and it is conveniently put in the decay tree hierarchy representing the event
history wrap-up.

Pandora implements reconstruction in a modular way: the framework encompasses
100 algorithms and is easily extended via sub-classing thanks
to the Object Oriented paradigm, it is built around. The modularity of Pandora
prefers to split the reconstruction process into several small steps with
dedicated algorithms, rather than a single end-to-end procedure: this ensures
more fine-grain control on the workflow and the ability to switch between
multiple implementations of the same method. The instructions and the list of
algorithms that should be run by the Pandora application are contained in XML
settings files.

The modularity of Pandora abstracts also the detector geometry to handle
different setups: specific geometry settings collect all the parameters needed
to design the detector where to run the reconstruction in. The main parameters
included in a geometry file for a LArTPC detector are the number of drift
chambers with their spatial extent in the cartesian frame of reference. The
orientation of the wires in each wire plane with respect to the vertical, which
fixes the wire pitch direction. The detector gaps simulate un-responsive
channels or regions populated with a low number of wires if any. The current
Pandora framework supports different geometries for LArTPC detectors, such as
ICARUS [255], MicroBooNE, ProtoDUNE-SP, ProtoDUNE Dual Phase
(DP) [256] and the DUNE Far Detector. In the following, we will
focus on ProtoDUNE-SP only, but the discussion can be easily generalized to all
the different LArTPC realizations.

Scheme of the Pandora reconstruction workflow for a ProtoDUNE-SP
event. The red blobs refer to data structures that serve as inputs for the
Pandora algorithms or their products. White boxes identify high-level
reconstruction step and are gathered into two main pipelines:
and . In the middle, the
slicing algorithm aims at isolating the Test Beam related CaloHits. The CR
muon tagging algorithm, labeled by a dashed box, is taken from the LArSoft

Figure <ref> represents the flowchart of a Pandora run for
a ProtoDUNE-SP reconstruction event. The inputs are the $2{-}$dimensional CaloHits
from either simulation or real detector data. The diagram, then, splits the
process into three main pipelines, namely , slicing and
. The first step aims at reconstructing the CaloHits
belonging to cosmic rays (CRs): many LArTPC detectors are built underground (such
as the DUNE FD) and are shielded by hundreds of meters of rock, however, others
are surface detectors (like MicroBooNE and ProtoDUNE) and they record events
contaminated by CR muons interacting at high angles in the fiducial volume
producing long ionization tracks. This effect is even more emphasized by the
long readout windows of a few milli-seconds required to observe LArTPCs signals
due to the rather small electron drift speed, which includes many CR tracks in
each event. For example, we expect an $\orderof{50}$ of CR interactions for each
event at ProtoDUNE-SP (readout window of $\SI{3}{\milli\s}$). The
outputs a list of  that
unambiguously identifies the CR muons CaloHits that will not be available for
the next steps.

The slicing algorithm runs just after the first main pipeline and its goal is to
group the CaloHits related to the same main interacting particle and its
subsequent decays. The output of such a procedure is comprised of multiple sets
of CaloHits named slices.

The  pipeline further analyzes the CaloHit remnants from
the previous steps and aims at reconstructing the data structures related to the
test beam (TB) depositions. In other detectors involving neutrino beams from
accelerator sources, such as MicroBooNE, this pipeline is replaced by the
analogous , described in detail by [254]. The
final output of such groups of algorithms is a list of test beam or neutrino
$3{-}$dimensional particles that are inserted in the event interaction tree.

The  pipeline is track-oriented, given that CRs
generate long ionization tracks in the detector rather than particle showers.
The inputs of this pipeline are all the $2{-}$dimensional CaloHits extracted from
an event generated by LArSoft. At ProtoDUNE-SP, we identify three main CaloHitLists
associated with the three wire planes $\mathrm{U}$, $\mathrm{V}$ and
$\mathrm{W}$. Each CaloHitList undergoes a $2{-}$dimensional clustering procedure
that groups together the hits employing topological algorithms. The objective of
this first stage is to create high-purity small clusters to be merged afterward,
rather than complete ones. Purity is the fraction of hits in a cluster that
indeed belong to the true MCParticle associated with the cluster. On the other
hand, completeness is the percentage of the true MCParticle CaloHits that are
included in the Cluster2D.

After the first clusters are created, the Pandora framework tries to associate
and extend the clusters to increase completeness without affecting the
purity. This is done by extracting geometrical information about cluster pairs
considering geometrical information such as cluster proximity and orientation.
A further cluster refinement is done with the output of this merging step looking
for clusters that should be split, instead. Indeed, clusters that present
discontinuities or intersections in the overall track envelope are split into two
clusters to preserve the purity metric.

Once the three separate ClustersList2D are generated, the $3{-}$dimensional
reconstruction algorithms aim to match the different $2{-}$dimensional plane
views into a single detector view. The key idea is to link together the different
Cluster2D objects from the three views if they refer to the same Track3D. Several
algorithms run in this step to identify and resolve ambiguities among
the different plane views. Two main algorithms known as ThreeDTransverseTracks
and ThreeDLongitudinalTracks achieve these goals for ionization tracks with a long
or small extension in the $x$ drift coordinate, respectively.

The CR ray muons often generate small secondary particle interactions out of
their main ionization tracks. These are secondary electrons that trigger small
curly depositions known as delta rays. At this stage of the reconstruction the
CaloHits related to these particles are already grouped into clusters, but they
still un-assigned to any $3{-}$dimensional object. The DeltaRayMatching algorithm
aims at identifying these delta rays and linking them to their parent muon track
based on their proximity.

The input $2{-}$dimensional CaloHits are grouped into clusters and tracks and,
at this stage, Pandora populates the list of $3{-}$dimensional CaloHits
reconstructed from the input ones. The CR reconstruction terminates with
identifying the track's end-points (the starting point is always at the highest
$y$ value since CRs come from above), creating a Muon3DParticle along with
Vertices objects at each delta ray emission. Before exiting the pipeline, the
CaloHits associated with the reconstructed CR objects are removed from the
input lists.

After cosmic rays removal by the previous pipeline, the CaloHits should contain
only the TB or the neutrino-associated hits, depending on the specific LArTPC
application. However, since failures in CR identification might occur, whatever
downstream pipeline, namely  or , should
be able to handle CR remnants properly. Therefore, Pandora runs at this
intermediate stage the slicing algorithm: its primary objective is to separate
the CR remnants CaloHits from the TB or neutrino ones. As a plus, it proceeds to
assign the available CaloHits to separate clusters based on the main interacting
parent particle. This way, not only the TB or $\nu$ particles are kept divided
from the rest of the CaloHits, but also it should be easier to run once more
the reconstruction on the CR remnants.

The Pandora implementation of the slicing algorithm is based on topological
considerations and completely ignores the energy information contained by
the CaloHits. The core methods connected with this algorithm are the
and the , which
respectively consist in fitting a track and shower envelope around the available
clusters in the $3{-}$dimensional space after a first fit has been done on the
$2{-}$dimensional objects projections. The resulting tracks and shower clusters
are allowed to seed a new slice if they group more than $50$ CaloHits. Once a new
slice is created all the clusters associated with the seeding one are gathered
inside the same slice. The association of each candidate cluster is done through
pointing (mainly orientation and parent-daughter relationship) and proximity
(minimum inter-cluster distance) conditions with the main seeding cluster for
track-like products and percentage overlapping with the main shower cone envelope
for the shower-like ones.

The algorithm ensures that all the clusters get tested to be included into a
slice traversing all the possible clusters with a Breadth First Search approach.
This way, the CaloHits associated with each seeding cluster are collected inside
their relevant slice. However, it can be the case that small isolated clusters do
not get linked with any slice because they do not pass the conditional statements
listed above. The software, therefore, takes care of these remaining clusters
building a $3{-}$dimensional k-d tree graph for fast cluster querying:
the k-d tree nodes are fixed to the positions of the CaloHits already in the
slices and the centroid point of each remnant cluster is checked to be included
in the slice of the closest k-d tree node.

Figure <ref> provides an example of the slicing tool output for an
event with cosmic rays plus a test beam. At ProtoDUNE-SP TB is a mixture of charged
particles with given energy (mainly $p$, $e^+$ and $\pi^+$). The hits in the image
are color-coded, depending on which final slice they belong to.

Cosmics rays and test beam
event: U plane view. Hits with the same color belong to the same main
Monte Carlo simulated particle.

U plane view: 2D initial
clusters with more than $5$ hits computed by Pandora.

The  pipeline is associated with the reconstruction of
the CaloHits due to the test beam interactions with the liquid Argon. The test
beam at ProtoDUNE is mainly comprised of hadrons, while neutrinos are the main
constituents of the beam flux to which MicroBooNE is exposed. Even if the
composition of the beams is different, Pandora treats the two problems almost
in the same way. We stress that the input CaloHits of this step should not
contain CR muon tracks anymore, even if remnants can still be addressed at this

The TB pipeline differs from the CR one mainly by two aspects: the vertex
selection and the reconstruction of primary electromagnetic showers. In
particular, the vertex reconstruction starts considering all the possible vertex
candidates in the $3{-}$dimensional space as a result of the
CandidateVertexCreation algorithm. Pandora proceeds, then, to evaluate a score
metric for each vertex candidate to identify the fittest, which turns
out to be the one with the maximum score. The metric is built around three
different contributions that can be weighted to tunable parameters to tweak the
relative importance of each factor.

The first contribution is dubbed as energy kink and depends on the sum
of each cluster total reconstructed energy projected on each $2{-}$dimensional
view, plus an impact parameter measuring the displacement of each cluster from
the vertex. The idea is that secondary interactions downstream of the interaction
vertex should be less energetic than primary particles, such as TB ones or CR.

The second contribution describes the asymmetry of the vertex splitting:
it has been introduced to suppress vertex candidates that arise in the middle of
long tracks, splitting the depositions into approximately the same number of
downstream and upstream CaloHits. Pandora favors configurations with large
values of such asymmetry parameters, underlining that the vertex occurs near
the track end-points.

The last factor influencing the vertex metric is the beam deweighting
score, which measures the $z$ coordinate placement of the vertex. The vertex
position is better placed at low values of the $z$ coordinate, which means near
the TB source. This quantity strongly depends on the normalized $z$ position of
the candidate vertex.

Once the TBVertices3D vector is computed, Pandora starts the track and shower
reconstruction. The former aims at finding the CR remnants, along with TB
particles (such as protons, pions and muons) that produce track-like depositions;
the latter identifies two kinds of objects: shower spines and shower branches.
The shower-like clusters are divided into two categories by the length of
the associated $2{-}$dimensional clusters: long clusters are spines and are
typically oriented towards the interaction vertex, while the shorter ones
represent branches and might also be displaced from the main spine. The
algorithm dedicated to recursively building up the $2{-}$dimensional showers is
named ShowerGrowing. After this stage, the shower projections are matched into
the $3{-}$dimensional objects by resolving all the possible ambiguities that may

Further algorithms refine and complete the high-level objects created during the
pipeline so far. Therefore, a second
$3{-}$dimensional reconstruction is run with less stringent thresholds to ensure
that all the CaloHits are conveniently placed in their corresponding object.
The Pandora software is finally ready to build the particle hierarchy wrap-up,
recursively looking from the primary particles to their daughters while tagging
all the primary and secondary interaction vertices in the event.

§ THE CLUSTER MERGING NETWORK

Network design

We introduce the novel slicing method based on the Cluster Merging Network
(CM-Net) [250]: an agglomerative clustering algorithm, in which we train a neural
network to decide if sub-clusters from a 2D initial cluster pair should be merged
or not. A successful link of two 2D clusters should happen if they are
formed by hits generated by the same interaction. This information is
available in the simulation and it is used as the ground truth in the CM-Net
supervised training. The objective is to build an undirected graph, where the
nodes are the 2D initial clusters in an event plane view and the resulting
different disconnected parts of the graph are interpreted as slices.
Eventually, two specific 2D hits in a plane view will belong to the same slice if
there exists a path in the graph connecting their corresponding 2D initial

We underline that this method is not able to split an initial 2D cluster into two
parts. Thus, amending reconstruction errors arising from a previous step of the
Pandora reconstruction is not possible. This approach is supported by the fact
that the Pandora reconstructed objects show high purity, that is the percentage
of hits in a 2D initial cluster falling in the same Monte Carlo true slice,
even before the slicing takes place. Figure <ref> captures
this behavior: since a cluster merging procedure can only lower the purity of the
resulting set with respect to the initial cluster purities, this benchmark sets
an upper bound of the purity of the CM-Net approach. The mean of the purity
histogram exceeds $90\%$.

[scale=0.4, height=2in]initial_clusters_purities.png
2D initial clusters purity. The
histogram is peaked towards high purity values.

[scale=0.4, height=1.8in]cmnet.png
The CM-Net network architecture:
given a feature vector of the cluster pair, outputs the probability that
the cluster pair should be merged.

Figure <ref> depicts our CM-Net, which is realized as a stack of fully
connected layers, with sigmoid final activation. The CM-Net takes as input a
vector of fixed size for each pair of sub-clusters in the plane view. The array
contains a set of $29$ intra-cluster features computed independently for each
sub-cluster. We add the same quantities extracted from the sample of hits that
would be obtained by merging the two candidate sub-clusters. Finally, we
concatenate two more inter-cluster scalar measures. The total length of the
network input vector is therefore of $89$ elements.

3cIntra-cluster features

3*Standard stats $(5)$     Hits percentage     $|h_{\mathcal{C}}| / h_{\mathrm{tot}}$

Hits mean position     $\mathbf{\bar{h}} = (\bar{h}_x, \bar{h}_y)$

Cluster expected direction      $\mathbf{v} = (v_x,v_y)$

4*Covariance matrix $(10)$     Elements     $Cov[h_x,h_y]_{ij}$

Eigenvalues      $\lambda_1, \lambda_2$

Eigenvalues importance    $\lambda_1 / (\lambda_1 + \lambda_2)$

Eigenvectors    $\mathbf{v}_{\lambda_1}, \mathbf{v}_{\lambda_2}$

2*Post-PCA $(9)$      Cluster end-points     $\mathbf{h}^{\mathrm{t}}$, $\mathbf{h}^{\mathrm{l}}$, $\mathbf{h}^{\mathrm{r}}$, $\mathbf{h}^{\mathrm{b}}$

Max end-points distance     ${\displaystyle \max_{i,j}} \|\mathbf{h}^i-\mathbf{h}^j\|$

2*Calorimetry $(2)$     Hit mean energy     $\bar{E}$

Hit energy std     $\sigma_E$

TPC view $(3)$     One-hot vector for U,V,W

3cInter-cluster features

2*Geometric stats $(2)$     Minimum inter-cluster distance     ${\displaystyle\min_{\mathcal{C}_1,\mathcal{C}_2}} \|\mathbf{h}_{\mathcal{C}_1} - \mathbf{h}_{\mathcal{C}_2}\| $

Expected angular separation     $\abs{\mathbf{\hat{v}}_1\cdot\mathbf{\hat{v}}_2}$

List of the extracted intra and inter-cluster features. The first
column groups the features into categories: the number in parentheses highlights
how many components of the final feature vector the specific category gathers.

Table <ref> collects the inter-cluster and intra-clusters
engineered features. We group the quantities into different categories. Five
standard values mainly come from the Pandora reconstruction and measure the
importance of the cluster in the event, in terms of the percentage of hits over
the total in the plane view, the average position in the plane and the expected
direction of the cluster. The latter is a quantity available within the Pandora
framework and gives information about the expected direction of the track
envelope in the plane.

The covariance matrix informs mainly about the shape of the point cloud formed
by the sub-cluster, namely how the hits are distributed in the plane. Hence, we
collect the elements of the covariance matrix as well as its eigenvalues
$\lambda_{1,2}$ and eigenvectors $\mathbf{v}_{\lambda_{1,2}}$. We further compute
the importance of the first eigenvalue normalizing it to the sum of the two:
$\lambda_1 / (\lambda_1 + \lambda_2)$.

The Principal Component Analysis (PCA) allows us to rotate and
rescale the position of each sub-cluster hit, identifying the directions of maximal
variance. Once the point cloud is transformed with the PCA algorithm, it is easy
to identify the hits at the boundaries of the point cloud $\mathbf{h}^{\mathrm{t,l,r,b}}$
(top, left, right, bottom) in the new $(x',z')$ plane, since they are now the
furthest ones away from the origin. Also, we consider the maximum euclidean pair
distance among the set of such end-point hits.

As opposed to the Pandora geometric approach, in this work, we include the calorimetry information, adding to the feature vector the mean and standard
deviation of the hit deposited energies.

Finally, we complete the list of the intra-cluster features with a one-hot vector
referring to which plane view the sub-cluster belongs to. This is a $3{-}$element
array corresponding to the different U, V and W planes.

The inter-cluster features read two scalar entries: the minimum inter-cluster
distance between hits and the expected angular separation, namely the cosine of
the angle between the two sub-cluster expected directions. In principle, the
former value should be inversely correlated to the probability that two
sub-clusters belong, in fact, to the same track. The latter quantity is
conveniently computed through the modulus of the inner product of the unit
vectors $\mathbf{\hat{v}}_{1,2}$ pointing towards the sub-cluster's expected

The dataset used to train and test our model collects only simulated data,
testing on detector data is out of the scope of the present work and can be
addressed in the future. We simulate $600$ events for training and $300$ for
testing purposes with the help of the LArSoft [245] framework.
Each event represents a test beam of charged particles with certain energy plus
cosmic rays interactions within ProtoDUNE-SP. We produce the same amount of
events for each of the available test beam energies: $0.3$, $0.5$, $1$, $2$, $6$,
$\SI{7}{\GeV}$. We remind the reader that each event is composed of three
different plane views and, in turn, it contains  $\mathcal{O}(\SI{10}{k})$ hits
and $\mathcal{O}(500)$ clusters of various size. We expect that each event
contains $\mathcal{O}(50)$ main interactions to be grouped into slices.

We train the CM-Net with the following setup. After collecting all the possible
2D input cluster pairs from the events in the training dataset, we filter out the
negative examples (those that should not be merged) to reach a $50\%$ balance
on the two classes. We reserve an array with $10\%$ of the examples as a
validation dataset. Validation is employed to choose the best model during
training, namely, the checkpoint on the epoch end that achieves the best validation
accuracy. The CM-Net is optimized using the Stochastic Gradient
Descent (SGD) [257] algorithm with a learning rate $\eta=5\cdot
10^{-3}$ and the binary cross-entropy as the loss function.

After training, we exploit the CM-Net to build the clusters graph: an edge
between a cluster pair is drawn if the output of the network exceeds a certain
threshold. In our experiment, we fix this threshold to $0.9$. We choose such
a high value to lower as much as possible the false positive rate: a single
positive mispredicted edge can cause a macroscopic effect at the graph level.
It is possible, indeed, that false positive edges establish a bridge between
two large disconnected parts of the graph, linking them together when, in fact,
they should remain separate. The final CM-Net graph prediction is turned
into a set of slices containing 2D detector hits, that can be compared against
the state-of-the-art Pandora slicing method output.

We build a benchmark to compare the goodness of the CM-Net slicing reconstruction
against the current Pandora implementation. Since ProtoDUNE-SP is a surface
detector, it is crucial to correctly identify and keep separate slices associated
with test beam (TB) hits and cosmic rays (CR) hits. We remind the reader that in
our experiments, we simulate a TB made of charged particles with a given energy.
The goal is to define metrics that allow us to tag the status of the
reconstruction on a plane view basis. Such figures of merit are the purity and
the completeness of a reconstructed TB slice: purity is the fraction of hits in
a reconstructed TB slice that is shared with the TB slice; completeness is the
fraction of hits from the true TB slice that is shared with the reconstructed
TB slice.

Based on these definitions, we mark each plane in the test set with a flag within
the following set: ,  or .
Figure <ref> illustrates the tagging procedure. The first branching
depends on the multiplicity of the reconstructed slices containing true TB hits.
If all true TB hits fall into the same reconstructed slice, the only
discriminant on the reconstruction status is its purity: above $90\%$ purity
threshold, the plane view is said to be , otherwise is .
The optimal output should not involve multiple TB slices.
Nonetheless, we allow a small margin of error in our tagging procedure, when the
highest reconstructed TB slice has both completeness and purity above $90\%$.
Conversely, if completeness is below the threshold, the plane is naturally marked
as  or if the output, instead, falls short in purity, it provides
the evidence that the TB slice has inevitably been merged () into a
CR larger slice.

Test beam benchmark flowchart:
marks each plane view as ,  or
. The threshold is $t=90\%$.

[width=0.85, height=1.8in]metrics.png
Reconstructing MC TB slices: green bars for CM-Net, red bars
for Pandora. Dashed lines represent the overall TB energy score. Rows
from top to bottom represent correct, lost and bottom percentages.

Figure <ref> collects the results of the TB reconstruction benchmark.
The top row shows that CM-Net achieves better accuracy than the current Pandora
baseline for all the available beam energies. The improvement of our algorithm
has to be identified in the less number of clusters marked as .
The CM-Net algorithm presents similar performance for all available TB energies
for both the  and  kind of predictions, while it
achieves worse score for the  category for at the lowest
($\SI{0.3}{\GeV}$) and highest ($\SI{7}{\GeV}$) ends of the TB energy range.

We showed that the
proposed model outperforms the state-of-the-art implementation within
the Pandora framework. This approach is compatible with the Pandora interface
and can be appointed for integration into the software in the future.
Further work directions include the assessment of the relative importance of each
input feature in the CM-Net final prediction, as well as the optimization of the
network architecture itself, inspecting new and more flexible solutions, such as
the attention mechanism [46] and its variants. Those
networks might exploit the data structure more naturally, avoiding manually
selecting and extracting feature arrays of fixed size from the clusters.

CHAPTER: FUTURE DIRECTIONS

tocchapterFuture directions

In this section, we introduce the main ideas to further developments of the
research presented in this thesis work. We point out the main objectives for
each of the four main results delivered by this study.

The development of the software is considered complete.
The challenge is to provide code maintenance through time, understanding and
matching the needs of the users of the package both from the point of view of
theoretical and experimental physicists. The implementation is sufficiently
modular that should allow to easily include new algorithms to extend the
capabilities of the tool.

The fundamental end-point for the successful spread of the framework
among the HEP community is the need to promote the software to include
next-to-leading order calculations in an automated way, exploiting the full
potential of hardware accelerators. The present work marked an important
milestone showing the possibility to hold the computation of a high number of
events even for complicated processes with multiple final state partons. This
sheds light on the feasibility to go to higher order in perturbation theory.
However, such computations involve complex subtraction techniques to take care
of QCD infrared singularities that might reveal difficult to implement within the
TensorFlow library.

Other chances to improve the software within reach are the development
of a more efficient and GPU-compatible phase space sampler. The current
implementation of RAMBO for GPU employs a flat phase space that represents a
potential shortcoming in the whole pipeline: complex query processes might introduce
instabilities in the cross-section integration and reduce the overall
event generation efficiency, requiring sampling more events than the GPU might
hold, inevitably slowing down the entire run. Possible solutions can be
investigated from studying adaptive sampling methods also implemented by the

Continuous integration and continuous development can be interesting approaches
for the maintenance of the package in the future: the idea is to
design a fully automated test suite to check corner cases and identify potential
bugs in the implementation to deploy the code in production

Denoising ProtoDUNE-SP raw data

Interpretability is one of the main issues related to deep learning, which
represents a big question mark on the behavior of these algorithms in new
environments. The main future research goal for both denoising and slicing deep
learning applications should be to test the networks with larger datasets and
eventually on real data. This investigation might require the implementation of
automated solutions for the management of the deep learning resources: efficient
data storing and retrieval from collected databases, continuous training
techniques to inspect new models and automatically triggered hyperparameter
search strategies. The deployment of these methods requires advanced software
engineering knowledge and experience.

Specific objectives for further developments of the networks implemented in the
context of ProtoDUNE-SP raw data denoising are the integration within the LArSoft
framework to allow easier comparison with the methods currently used by the DUNE
collaboration. This means scanning the suitable solutions to interface the Python
code, in which the Graph Neural Networks are implemented, with the LarSoft

Other interesting opportunities for further investigation of deep learning
methods in this study are model optimization and parameter pruning techniques
to provide faster inference with the presented neural networks

Slicing algorithm at ProtoDUNE-SP

A full test comparison with the Pandora implementation of the model shall be the
first phase of the future development of this research. The subsequent step would
be to integrate our solution within the Pandora framework and test it on real
detector data.

Further optimization of the current approach we introduced would be desirable to
provide faster inference performance.
The starting point would be to replace the sequential processing of the pairs of
$2{-}$dimensional sub-clusters in each plane view with more efficient operations.
The bottleneck might be represented by the fact that the number of sub-cluster
pairs to be inspected grows quadratically with the number of sub-clusters.
An interesting approach is given by the application of the attention
mechanism to the entire array of detector hits in each plane view.
This would allow to process entire plane views at the hit level with a single
network forward pass, rather than considering just sub-clusters pairs only.
The increased complexity of the algorithm would then require careful training
process management, although it might result in improved output performance.

[1]
J. Albrecht, et al., Comput. Softw. Big Sci. 3(1), 7 (2019).

[2]
S. Amoroso, et al., Comput. Softw. Big Sci. 5(1), 12 (2021).

[3]
S.F. Novaes, in 10th Jorge Andre Swieca Summer School: Particle and
Fields (1999), pp. 5–102.

[4]
J.M. Butterworth, Philosophical Transactions of the Royal Society A:
Mathematical, Physical and Engineering Sciences 374(2075), 20150260

[5]
E.R. Paudel, BMC Journal of Scientific Research 4(1), 65 (2021).

[6]
M.E. Peskin, D.V. Schroeder, An Introduction to quantum field theory
(Addison-Wesley, Reading, USA, 1995)

[7]
P.W. Higgs, Phys. Rev. Lett. 13, 508 (1964).

[8]
Standard Model.

[9]
F.J. Gilman, K. Kleinknecht, B. Renk, Eur. Phys. J. C 15, 110 (2000).

[10]
L.L. Chau, W.Y. Keung, Phys. Rev. Lett. 53, 1802 (1984).

[11]
M. Kobayashi, T. Maskawa, Progress of Theoretical Physics 49(2), 652

[12]
R.L. Workman, Others, PTEP 2022, 083C01 (2022).

[13]
S. Schael, et al., Phys. Rept. 427, 257 (2006).

[14]
B. Pontecorvo, Sov. Phys. JETP 6, 429 (1957)

[15]
B. Pontecorvo, Zh. Eksp. Teor. Fiz. 34, 247 (1957)

[16]
Z. Maki, M. Nakagawa, S. Sakata, Prog. Theor. Phys. 28, 870 (1962).

[17]
B. Pontecorvo, Zh. Eksp. Teor. Fiz. 53, 1717 (1967)

[18]
V.N. Gribov, B. Pontecorvo, Phys. Lett. B 28, 493 (1969).

[19]
J.D. Vergados, H. Ejiri, F. Simkovic, Rept. Prog. Phys. 75, 106301

[20]
S. Dell'Oro, S. Marcocci, M. Viel, F. Vissani, Adv. High Energy Phys.
2016, 2162659 (2016).

[21]
S.M. Bilenky, J. Hosek, S.T. Petcov, Phys. Lett. B 94, 495 (1980).

[22]
V. Barger, K. Whisnant, R.J.N. Phillips, Phys. Rev. Lett. 45, 2084

[23]
C. Giganti, S. Lavignac, M. Zito, Prog. Part. Nucl. Phys. 98, 1

[24]
R.L. Workman, Others, PTEP 2022, 083C01 (2022).

[25]
K. Abe, et al., Phys. Rev. D 97(7), 072001 (2018).

[26]
Esteban, I. and others.
Nufit4.1 at nufit webpage (2021).

[27]
F. Capozzi, E. Lisi, A. Marrone, A. Palazzo, Prog. Part. Nucl. Phys.
102, 48 (2018).

[28]
P.F. de Salas, D.V. Forero, C.A. Ternes, M. Tortola, J.W.F. Valle, Phys. Lett.
B 782, 633 (2018).

[29]
K.E. Atkinson, An Introduction to Numerical Analysis, 2nd edn. (John
Wiley & Sons, New York, 1989).

[30]
R. Kleiss, R. Pittau, Comput. Phys. Commun. 83, 141 (1994).

[31]
G.P. Lepage, J. Comput. Phys. 27, 192 (1978).

[32]
G.P. Lepage.
VEGAS: AN ADAPTIVE MULTIDIMENSIONAL INTEGRATION PROGRAM (1980).

[33]
L. Lönnblad, Computer Physics Communications 84(1), 307 (1994).

[34]
R. Brun, F. Rademakers, Nucl. Instrum. Meth. A 389, 81 (1997).

[35]
G.E. Forsythe, Mathematics of Computation 26(120), 817 (1972).

[36]
W.K. Hastings, Biometrika 57, 97 (1970).

[37]
E. Byckling, K. Kajantie, Particle Kinematics: (Chapters I-VI, X)
(University of Jyvaskyla, Jyvaskyla, Finland, 1971).

[38]
R. Kleiss, W.J. Stirling, S.D. Ellis, Comput. Phys. Commun. 40, 359

[39]
I.J. Goodfellow, Y. Bengio, A. Courville, Deep Learning (MIT Press,

[40]
T.M. Mitchell, Machine learning (McGraw-hill New York, 1997).
<http://www.cs.cmu.edu/ tom/mlbook.html>

[41]
D. Li, IEEE Signal Processing Magazine 29(6), 141 (2012).

[42]
F. Pedregosa, et al., Journal of Machine Learning Research 12, 2825

[43]
K. Hornik, M. Stinchcombe, H. White, Neural Netw. 2(5), 359 (1989).

[44]
D.X. Zhou, Applied and Computational Harmonic Analysis 48(2), 787

[45]
Y.T. Zhou, R. Chellappa, in IEEE 1988 International Conference on Neural
Networks (1988), pp. 71–78 vol.2.

[46]
A. Vaswani, N. Shazeer, N. Parmar, J. Uszkoreit, L. Jones, A.N. Gomez,
L. Kaiser, I. Polosukhin, in Advances in Neural Information Processing
Systems, vol. 30, ed. by I. Guyon, U.V. Luxburg, S. Bengio, H. Wallach,
R. Fergus, S. Vishwanathan, R. Garnett (Curran Associates, Inc., 2017),
vol. 30.

[47]
T. Wolf, L. Debut, V. Sanh, J. Chaumond, C. Delangue, A. Moi, P. Cistac,
T. Rault, R. Louf, M. Funtowicz, J. Davison, S. Shleifer, P. von Platen,
C. Ma, Y. Jernite, J. Plu, C. Xu, T.L. Scao, S. Gugger, M. Drame, Q. Lhoest,
A.M. Rush, in Proceedings of the 2020 Conference on Empirical Methods
in Natural Language Processing: System Demonstrations (Association for
Computational Linguistics, Online, 2020), pp. 38–45.

[48]
K. Choromanski, et al., CoRR abs/2009.14794 (2020).

[49]
A. Dosovitskiy, L. Beyer, A. Kolesnikov, D. Weissenborn, X. Zhai,
T. Unterthiner, M. Dehghani, M. Minderer, G. Heigold, S. Gelly, J. Uszkoreit,
N. Houlsby, CoRR abs/2010.11929 (2020).

[50]
G. Rumelhart, D. E. adnd Hinton, R.J. Williams, Nature 323, 533

[51]
D.P. Kingma, J. Ba.
Adam: A method for stochastic optimization (2017).

[52]
HEP ML Community.
A Living Review of Machine Learning for Particle Physics (2022).

[53]
D. Guest, K. Cranmer, D. Whiteson, Annual Review of Nuclear and Particle
Science 68(1), 161 (2018).

[54]
P. F., M. Groh, C. Tunnell, K. Warburton, International Journal of Modern
Physics A 35(33), 2043005 (2020).

[55]
H. Voss, A. Höcker, J. Stelzer, F. Tegenfeldt, in Proceedings of XI
International Workshop on Advanced Computing and Analysis Techniques in
Physics Research — PoS(ACAT), vol. 050 (2009), vol. 050, p. 040.

[56]
A. Krizhevsky, I. Sutskever, G. Hinton, in Proceedings of the 25th
International Conference on Neural Information Processing Systems - Volume 1
(Curran Associates Inc., Red Hook, NY, USA, 2012), NIPS'12, pp. 1097–1105.

[57]
Y. LeCun, Y. Bengio, G. Hinton, Nature 521, 436 (2015).

[58]
J. Schmidhuber, Neural Networks 61, 85 (2015).

[59]
S. Agostinelli, J. Allison, K. Amako, J. Apostolakis, et al., Nuclear
Instruments and Methods in Physics Research Section A: Accelerators,
Spectrometers, Detectors and Associated Equipment 506(3), 250

[60]
T. Sjöstrand, S. Mrenna, P. Skands, Journal of High Energy Physics
2006(05), 026 (2006).

[61]
M. Bähr, S. Gieseke, M. Gigg, D. Grellscheid, K. Hamilton, Latunde-Da.,
S. Plätzer, P. Richardson, M. Seymour, A. Sherstnev, B. Webber, The European
Physical Journal C 58, 639 (2008).

[62]
T. Gleisberg, S. Höche, F. Krauss, M. Schönherr, S. Schumann, F. Siegert,
J. Winter, Journal of High Energy Physics 2009(02), 007 (2009).

[63]
J. Alwall, R. Frederix, S. Frixione, V. Hirschi, F. Maltoni, O. Mattelaer, H.S.
Shao, T. Stelzer, P. Torrielli, M. Zaro, Journal of High Energy Physics
2014 (2014).

[64]
I. Goodfellow, J. Pouget-Abadie, M. Mirza, B. Xu, D. Warde-Farley, S. Ozair,
A. Courville, Y. Bengio, in Advances in Neural Information Processing
Systems, vol. 27, ed. by Z. Ghahramani, M. Welling, C. Cortes, N. Lawrence,
K. Weinberger (Curran Associates, Inc., 2014), vol. 27.

[65]
P. Baldi, P. Sadowski, D. Whiteson, Nature Commun. 5, 4308 (2014).

[66]
O. Cerri, T.Q. Nguyen, M. Pierini, M. Spiropulu, J.R. Vlimant, JHEP
05, 036 (2019).

[67]
E. Bernreuther, T. Finke, F. Kahlhoefer, M. Krämer, A. Mück, SciPost Phys.
10(2), 046 (2021).

[68]
D. Cogollo, F.F. Freitas, C.A. de S. Pires, Y.M. Oviedo-Torres, P. Vasconcelos,
Phys. Lett. B 811, 135931 (2020).

[69]
R.T. D'Agnolo, A. Wulzer, Phys. Rev. D 99(1), 015014 (2019).

[70]
R.T. d'Agnolo, G. Grosso, M. Pierini, A. Wulzer, M. Zanetti, Eur. Phys. J. C
82(3), 275 (2022).

[71]
M. Cacciari, G.P. Salam, G. Soyez, JHEP 04, 005 (2008).

[72]
M. Cacciari, G.P. Salam, S. Sapeta, JHEP 2010 (2010).

[73]
M. Rubin, JHEP 05, 005 (2010).

[74]
L. Lönnblad, C. Peterson, T. Rögnvaldsson, Phys. Rev. Lett. 65,
1321 (1990).

[75]
T. Behnke, D. Charlton, Physica Scripta 52(2), 133 (1995).

[76]
C. Peterson, T. Rögnvaldsson, L. Lönnblad, Computer Physics Communications
81(1), 185 (1994).

[77]
J. Cogan, M. Kagan, E. Strauss, A. Schwarztman, JHEP 02, 118 (2015).

[78]
R.A. Fisher, Annals of Eugenics 7(2), 179 (1936).

[79]
J. Thaler, K. Van Tilburg, JHEP 03, 015 (2011).

[80]
J. Thaler, K. Van Tilburg, JHEP 02, 093 (2012).

[81]
L.G. Almeida, M. Backović, M. Cliche, S.J. Lee, M. Perelstein, JHEP
07, 086 (2015).

[82]
P. Baldi, K. Bauer, C. Eng, P. Sadowski, D. Whiteson, Phys. Rev. D
93(9), 094034 (2016).

[83]
J. Barnard, E.N. Dawe, M.J. Dolan, N. Rajcic, Phys. Rev. D 95(1),
014018 (2017).

[84]
L. de Oliveira, M. Kagan, L. Mackey, B. Nachman, A. Schwartzman, JHEP
07, 069 (2016).

[85]
P.T. Komiske, E.M. Metodiev, M.D. Schwartz, JHEP 01, 110 (2017).

[86]
F.A. Dreyer, G.P. Salam, G. Soyez, JHEP 12, 064 (2018).

[87]
Y.L. Dokshitzer, G.D. Leder, S. Moretti, B.R. Webber, JHEP 08, 001

[88]
M. Wobisch, T. Wengler, in Workshop on Monte Carlo Generators for HERA
Physics (Plenary Starting Meeting) (1998), pp. 270–279.

[89]
M. Cacciari, G.P. Salam, G. Soyez, Eur. Phys. J. C 72, 1896 (2012).

[90]
D. Guest, J. Collado, P. Baldi, S.C. Hsu, G. Urban, D. Whiteson, Phys. Rev. D
94, 112002 (2016).

[91]
S. Hochreiter, J. Schmidhuber, Neural Computation 9(8), 1735 (1997).

[92]
ATLAS Collaboration.
Identification of Jets Containing $b$-Hadrons with Recurrent Neural
Networks at the ATLAS Experiment (2017).

[93]
ATLAS Collaboration.
Optimisation and performance studies of the ATLAS $b$-tagging
algorithms for the 2017-18 LHC run (2017).

[94]
CMS Collaboration.
Heavy flavor identification at CMS with deep neural networks

[95]
CMS Collaboration.
Performance of heavy flavour identification algorithms in
proton-proton collisions at 13 TeV at the CMS experiment (2017).

[96]
S. Egan, W. Fedorko, A. Lister, J. Pearkes, C. Gay.
Long short-term memory (lstm) networks with jet constituents for
boosted top tagging at the lhc (2017).

[97]
T. Cheng, Comput. Softw. Big Sci. 2(1), 3 (2018).

[98]
I. Henrion, J. Brehmer, J. Bruna, K. Cho, K. Cranmer, G. Louppe, G. Rochette,
in Workshop on Deep Learning for Physical Sciences of the 31st Annual
Conference on Neural Information Processing Systems (NIPS17) (2017).

[99]
A. Santoro, D. Raposo, D.G.T. Barrett, M. Malinowski, R. Pascanu, P. Battaglia,
T. Lillicrap.
A simple neural network module for relational reasoning (2017).

[100]
P.T. Komiske, E.M. Metodiev, J. Thaler, JHEP 01, 121 (2019).

[101]
H. Qu, L. Gouskos, Phys. Rev. D 101(5), 056019 (2020).

[102]
Y. Wang, Y. Sun, Z. Liu, S.E. Sarma, M.M. Bronstein, J.M. Solomon, ACM Trans.
Graph. 38(5) (2019).

[103]
C.R. Qi, H. Su, K. Mo, L.J. Guibas.
Pointnet: Deep learning on point sets for 3d classification and
segmentation (2016).

[104]
A.J. Larkoski, I. Moult, B. Nachman, Phys. Rept. 841, 1 (2020).

[105]
ATLAS Collaboration.
Quark versus Gluon Jet Tagging Using Jet Images with the ATLAS
Detector (2017).

[106]
CMS Collaboration.
New Developments for Jet Substructure Reconstruction in CMS (2017).

[107]
J. Lin, M. Freytsis, I. Moult, B. Nachman, JHEP 10, 101 (2018).

[108]
G. Kasieczka, T. Plehn, M. Russell, T. Schell, JHEP 05, 006 (2017).

[109]
A. Butter, et al., SciPost Phys. 7, 014 (2019).

[110]
G. Louppe, K. Cho, C. Becot, K. Cranmer, JHEP 01, 057 (2019).

[111]
A. Andreassen, I. Feige, C. Frye, M.D. Schwartz, Eur. Phys. J. C
79(2), 102 (2019).

[112]
S. Chatrchyan, et al., JINST 9(10), P10009 (2014).

[113]
ATLAS Collaboration.
Characterization of interaction-point beam parameters using the pp
event-vertex distribution reconstructed in the atlas detector at the lhc

[114]
ATLAS Collaboration.
Performance of primary vertex reconstruction in proton-proton
collisions at $\sqrt{s}=$7 tev in the atlas experiment (2010).

[115]
CMS Collaboration.
Pileup Removal Algorithms (2014).

[116]
M. Cacciari, G.P. Salam, Phys. Lett. B 659, 119 (2008).

[117]
J.M. Butterworth, A.R. Davison, M. Rubin, G.P. Salam, Phys. Rev. Lett.
100, 242001 (2008).

[118]
S.D. Ellis, C.K. Vermilion, J.R. Walsh, Phys. Rev. D 80, 051501

[119]
S.D. Ellis, C.K. Vermilion, J.R. Walsh, Phys. Rev. D 81, 094023

[120]
D. Krohn, J. Thaler, L.T. Wang, JHEP 02, 084 (2010).

[121]
M. Cacciari, G.P. Salam, G. Soyez, Eur. Phys. J. C 75(2), 59 (2015).

[122]
D. Bertolini, P. Harris, M. Low, N. Tran, JHEP 10, 059 (2014).

[123]
P. Berta, M. Spousta, D.W. Miller, R. Leitner, JHEP 06, 092 (2014).

[124]
ATLAS Collaboration.
Constituent-level pile-up mitigation techniques in ATLAS (2017).

[125]
P.T. Komiske, E.M. Metodiev, B. Nachman, M.D. Schwartz, JHEP 12, 051

[126]
J. Arjona Martínez, O. Cerri, M. Pierini, M. Spiropulu, J.R. Vlimant, Eur.
Phys. J. Plus 134(7), 333 (2019).

[127]
K. Cho, B. van Merrienboer, D. Bahdanau, Y. Bengio.
On the properties of neural machine translation: Encoder-decoder
approaches (2014).

[128]
B. Maier, S.M. Narayanan, G. de Castro, M. Goncharov, C. Paus, M. Schott, Mach.
Learn. Sci. Tech. 3(2), 025012 (2022).

[129]
S. Carrazza, F.A. Dreyer, J. Phys. Conf. Ser. 1525, 012111 (2020).

[130]
T. Li, S. Liu, Y. Feng, G. Paspalaki, N. Tran, M. Liu, P. Li.
Semi-supervised Graph Neural Networks for Pileup Noise Removal

[131]
S.J. Brice.
The results of a neural network statistical event class analysis

[132]
D.S. Ayres, et al.
The NOvA Technical Design Report (2007).

[133]
A. Aurisano, A. Radovic, D. Rocco, A. Himmel, M.D. Messier, E. Niner,
G. Pawloski, F. Psihas, A. Sousa, P. Vahle, JINST 11(09), P09001

[134]
C. Szegedy, L. Wei, J. Yangqing, et al., in 2015 IEEE Conference on
Computer Vision and Pattern Recognition (CVPR) (2015).

[135]
P. Adamson, L. Aliaga, D. Ambrose, et al., Phys. Rev. Lett. 118,
231801 (2017).

[136]
J. Renner, et al., JINST 12(01), T01004 (2017).

[137]
J. Schechter, J.W.F. Valle, Phys. Rev. D 25, 2951 (1982).

[138]
E. Racah, S. Ko, P. Sadowski, W. Bhimji, C. Tull, S. Oh, P. Baldi, Prabhat.
Revealing Fundamental Physics from the Daya Bay Neutrino Experiment
using Deep Neural Networks (2016).

[139]
R. Acciarri, et al., JINST 12(03), P03011 (2017).

[140]
S. Aiello, et al., JINST 15(10), P10005 (2020).

[141]
B. Abi, et al., Phys. Rev. D 102(9), 092003 (2020).

[142]
P. Abratenko, et al., Phys. Rev. D 103(9), 092003 (2021).

[143]
L. Hertel, L. Li, P. Baldi, J. Bian, in Workshop on Deep Learning for
Physical Sciences of the 31st Annual Conference on Neural Information
Processing Systems (NIPS17) (2017).

[144]
J. Liu, J. Ott, J. Collado, B. Jargowsky, W. Wu, J. Bian, P. Baldi.
Deep-Learning-Based Kinematic Reconstruction for DUNE (2020).

[145]
L. Dominé, P.C. de Soux, F. Drielsma, D.H. Koh, R. Itay, Q. Lin, K. Terao,
K.V. Tsang, T.L. Usher, Phys. Rev. D 104(3), 032004 (2021).

[146]
O. Ronneberger, P. Fischer, T. Brox, in Medical Image Computing and
Computer-Assisted Intervention – MICCAI 2015 (Springer International
Publishing, Cham, 2015), pp. 234–241.

[147]
C. Adams, et al., Phys. Rev. D 99(9), 092001 (2019).

[148]
H. Yu, et al., JINST 16(01), P01036 (2021).

[149]
R. Acciarri, et al., JINST 17(01), P01018 (2022).

[150]
B. Graham, M. Engelcke, L. van der Maaten, in 2018 IEEE/CVF Conference on
Computer Vision and Pattern Recognition (2018), pp. 9224–9232.

[151]
F. Scarselli, M. Gori, et al., IEEE Transactions on Neural Networks
20(1), 61 (2009).

[152]
L. Dominé, K. Terao, Phys. Rev. D 102(1), 012005 (2020).

[153]
D.H. Koh, P. Côte De Soux, L. Dominé, F. Drielsma, R. Itay, Q. Lin,
K. Terao, K.V. Tsang, T.L. Usher.
Scalable, Proposal-free Instance Segmentation Network for 3D Pixel
Clustering and Particle Trajectory Reconstruction in Liquid Argon Time
Projection Chambers (2020).

[154]
N. Choma, F. Monti, L. Gerhardt, et al., in 2018 17th IEEE International
Conference on Machine Learning and Applications (ICMLA) (2018), pp.

[155]
Z. Qian, et al., Nucl. Instrum. Meth. A 1010, 165527 (2021).

[156]
F. Drielsma, Q. Lin, P.C. de Soux, L. Dominé, R. Itay, D.H. Koh, B.J. Nelson,
K. Terao, K.V. Tsang, T.L. Usher, Phys. Rev. D 104(7), 072004

[157]
S. Alonso-Monsalve, D. Douqa, C. Jesús-Valls, T. Lux, S. Pina-Otey,
F. Sánchez, D. Sgalaberna, L.H. Whitehead, Phys. Rev. D 103(3),
032005 (2021).

[158]
J. Hewes, et al., EPJ Web Conf. 251, 03054 (2021).

[159]
C. Adams, K. Terao, T. Wongjirad.
PILArNet: Public Dataset for Particle Imaging Liquid Argon Detectors
in High Energy Physics (2020).

[160]
J. Martín-Albo, et al., JHEP 05, 159 (2016).

[161]
P. Abratenko, et al., Phys. Rev. D 103(5), 052012 (2021).

[162]
S.Y.C. Chen, T.C. Wei, C. Zhang, H. Yu, S. Yoo, Phys. Rev. Res. 4(1),
013231 (2022).

[163]
B. Clerbaux, M.C. Molla, P.A. Petitjean, Y. Xu, Y. Yang, IEEE Trans. Nucl. Sci.
68(8), 2187 (2021).

[164]
R. Abbasi, et al., JINST 16, P07041 (2021).

[165]
R. Frühwirth, R.K. Bock, Data analysis techniques for high-energy
physics experiments, vol. 11 (Cambridge University Press, 2000)

[166]
F. Ragusa, L. Rolandi, New J. Phys. 9, 336 (2007).

[167]
R. Frühwirth, A. Strandlie.
Pattern recognition and reconstruction: Datasheet from
landolt-börnstein - group i elementary particles, nuclei and atoms
˙ volume 21b1: “detectors for particles and radiation.
part 1: Principles and methods”.
Part of SpringerMaterials

[168]
H. Kälviäinen, P. Hirvonen, L. Xu, E. Oja, Image Vis. Comput.
13(4), 239 (1995).

[169]
R.E. Kalman, Journal of Basic Engineering 82(1), 35 (1960).

[170]
D.E. Catlin, The Discrete Kalman Filter (Springer New York, New York,
NY, 1989).

[171]
R. Fruhwirth, Nucl. Instrum. Meth. A 262, 444 (1987).

[172]
R. Mankel, Nucl. Instrum. Meth. A 395, 169 (1997).

[173]
B. Schmidt, J. Phys. Conf. Ser. 706(2), 022002 (2016).

[174]
The HEP.TrkX Collaboration.
Hep advanced tracking algorithms with cross-cutting applications

[175]
S. Farrell, D. Anderson, P. Calafiura, G. Cerati, L. Gray, J. Kowalkowski,
M. Mudigonda, Prabhat, P. Spentzouris, M. Spiropoulou, A. Tsaris, J.R.
Vlimant, S. Zheng, EPJ Web Conf. 150, 00003 (2017).

[176]
A. Tsaris, et al., Journal of Physics: Conference Series 1085(4),
042023 (2018).

[177]
S. Farrell, et al., in 4th International Workshop Connecting The Dots
2018 (2018).

[178]
X. Ju, et al., Eur. Phys. J. C 81(10), 876 (2021).

[179]
S.e.o. Amrouche, in The NeurIPS '18 Competition, ed. by S. Escalera,
R. Herbrich (Springer International Publishing, Cham, 2020), pp. 231–264.

[180]
The Exa.TrkX Collaboration.
Hep advanced tracking algorithms at the exascale (2019).

[181]
X. Ju, et al., in 33rd Annual Conference on Neural Information
Processing Systems (2020).

[182]
N. Choma, et al., in Proceedings of the 2020 Connecting The Dots
Workshop (2020).

[183]
A. Elabd, et al., Front. Big Data 5, 828666 (2022).

[184]
S. Carrazza, J.M. Cruz-Martinez, M. Rossi, Comput. Phys. Commun. 264,
107995 (2021).

[185]
M. Rossi, S. Carrazza, J.M. Cruz-Martinez, in Proceedings of 40th
International Conference on High Energy physics —
PoS(ICHEP2020), vol. 390 (2021), vol. 390, p. 921.

[186]
L.A. Harland-Lang, A.D. Martin, P. Motylinski, R.S. Thorne, Eur. Phys. J. C
75(5), 204 (2015).

[187]
R.D. Ball, et al., Eur. Phys. J. C 77(10), 663 (20).

[188]
C.P. Yuan, et al., in Proceedings of XXVII International Workshop on
Deep-Inelastic Scattering and Related Subjects — PoS(DIS2019),
vol. 352 (2019), vol. 352, p. 001.

[189]
H. Plothow-Besch, Comput. Phys. Commun. 75, 396 (1993).

[190]
M.R. Whalley, D. Bourilkov, R.C. Group, in HERA and the LHC: A Workshop
on the Implications of HERA and LHC Physics (Startup Meeting, CERN, 26-27
March 2004; Midterm Meeting, CERN, 11-13 October 2004) (2005), pp.

[191]
D. Bourilkov, R.C. Group, M.R. Whalley.
Lhapdf: Pdf use from the tevatron to the lhc (2006).

[192]
A. Buckley, J. Ferrando, S. Lloyd, K. Nordström, B. Page, M. Rüfenacht,
M. Schönherr, G. Watt, Eur. Phys. J. C 75, 132 (2015).

[193]
S. Carrazza, J.M. Cruz-Martinez, Comput. Phys. Commun. 254, 107376

[194]
J.M. Cruz-Martinez, S. Carrazza.
N3pdf/vegasflow: vegasflow v1.0 (2020).

[195]
M. Abadi, et al.
TensorFlow: Large-scale machine learning on heterogeneous systems
Software available from tensorflow.org

[196]
Python package index - pypi.

[197]
C.R. Harris, et al., Nature 585(7825), 357 (2020).

[198]
T. Gehrmann, et al., in Proceedings, 13th International Symposium on
Radiative Corrections: Application of Quantum Field Theory to Phenomenology
(RADCOR2017): St. Gilgen, Austria, September 24-29, 2017, vol. RADCOR2017
(2018), vol. RADCOR2017, p. 074.

[199]
J. Campbell, T. Neumann, JHEP 12, 034 (2019).

[200]
J. Cruz-Martinez, T. Gehrmann, E. Glover, A. Huss, Phys. Lett. B 781,
672 (2018).

[201]
A. Gehrmann-De Ridder, T. Gehrmann, E. Glover, JHEP 09, 056 (2005).

[202]
J. Currie, E.W.N. Glover, S. Wells, JHEP 04, 066 (2013).

[203]
V. Bertone, S. Carrazza, N.P. Hartland, Comput. Phys. Commun. 212, 205

[204]
S. Carrazza, J. Cruz-Martinez, Eur. Phys. J. C79(8), 676 (2019).

[205]
A. Valassi, S. Roiser, O. Mattelaer, S. Hageboeck, EPJ Web Conf. 251,
03045 (2021).

[206]
A. Valassi, et al.
madgraph5/madgraph4gpu: vchep2021 proceedings (2021).

[207]
NVIDIA, P. Vingelmann, F.H. Fitzek.
Cuda, release: 10.2.89 (2020).

[208]
S. Carrazza, J. Cruz-Martinez, M. Rossi, M. Zaro, EPJ Web Conf. 251,
03022 (2021).

[209]
S. Carrazza, J. Cruz-Martinez, M. Rossi, M. Zaro, Eur. Phys. J. C
81(7), 656 (2021).

[210]
J.M. Cruz-Martinez, S. Carrazza, M. Rossi, M. Zaro.
N3pdf/madflow: Beta release for madflow (2021).

[211]
N.D. Christensen, C. Duhr, Comput. Phys. Commun. 180, 1614 (2009).

[212]
C. Degrande, C. Duhr, B. Fuks, D. Grellscheid, O. Mattelaer, T. Reiter, Comput.
Phys. Commun. 183, 1201 (2012).

[213]
J. Alwall, M. Herquet, F. Maltoni, O. Mattelaer, T. Stelzer, JHEP 06,
128 (2011).

[214]
H. Murayama, I. Watanabe, K. Hagiwara.
HELAS: HELicity amplitude subroutines for Feynman diagram
evaluations (1992).

[215]
F. Maltoni, K. Paul, T. Stelzer, S. Willenbrock, Phys. Rev. D 67,
014026 (2003).

[216]
P. de Aquino, W. Link, F. Maltoni, O. Mattelaer, T. Stelzer, Comput. Phys.
Commun. 183, 2254 (2012).

[217]
J.R. Andersen, et al.
Les Houches 2013: Physics at TeV Colliders: Standard Model Working
Group Report (2014).

[218]
F. Maltoni, T. Stelzer, JHEP 02, 027 (2003).

[219]
M. Rossi, S. Vallecorsa, Computing and Software for Big Science 6(1)

[220]
B. Abi, R. Acciarri, et al., JINST 15(08), T08008 (2020).

[221]
B. Abi, et al.
Deep Underground Neutrino Experiment (DUNE), Far Detector Technical
Design Report, Volume II: DUNE Physics (2020).

[222]
B. Abi, R. Acciarri, et al., JINST 15(08), T08009 (2020).

[223]
B. Abi, R. Acciarri, et al., JINST 15(08), T08010 (2020).

[224]
B. Abi, R. Acciarri, et al.
The Single-Phase ProtoDUNE Technical Design Report (2017).

[225]
A.A. Abud, et al., JINST 17(01), P01005 (2022).

[226]
Y. Li, et al., Nuclear Instruments and Methods in Physics Research Section A:
Accelerators, Spectrometers, Detectors and Associated Equipment 816,
160 (2016).

[227]
C. Adams, R. An, et al., Journal of Instrumentation 13(07), P07006

[228]
R. Acciarri, et al., JINST 12(02), P02017 (2017).

[229]
S. Ramo, Proc. Ire. 27, 584 (1939).

[230]
G. Cavalleri, E. Gatti, G. Fabri, V. Svelto, Nucl. Instrum. Meth. 92,
137 (1971).

[231]
L. Hamel, M. Julien, Nuclear Instruments and Methods in Physics Research
Section A: Accelerators, Spectrometers, Detectors and Associated Equipment
597(2), 207 (2008).

[232]
R. Veenhof, Nucl. Instrum. Meth. A 419, 726 (1998).

[233]
H. Nyquist, Phys. Rev. 32, 110 (1928).

[234]
R. Acciarri, C. Adams, et al., Journal of Instrumentation 12(08),
P08003 (2017).

[235]
B. Baller, JINST 12(07), P07010 (2017).

[236]
C. Adams, et al., JINST 13(07), P07007 (2018).

[237]
N. Wiener, Extrapolation, Interpolation, and Smoothing of Stationary Time
Series (The MIT Press, 1964)

[238]
D. Valsesia, G. Fracastoro, et al.
Image denoising with graph-convolutional neural networks (2019).

[239]
D. Valsesia, G. Fracastoro, et al.
Deep graph-convolutional image denoising (2019).

[240]
M. Simonovsky, N. Komodakis.
Dynamic edge-conditioned filters in convolutional neural networks on
graphs (2017).

[241]
Q. Liu, M. Kampffmeyer, et al.
Scg-net: Self-constructing graph neural networks for semantic
segmentation (2020).

[242]
T.N. Kipf, M. Welling, CoRR abs/1609.02907 (2016).

[243]
K. Xu, W. Hu, J. Leskovec, S. Jegelka, in International Conference on
Learning Representations (2019).

[244]
S. Xie, et al.
Aggregated residual transformations for deep neural networks (2017).

[245]
E.D. Church.
Larsoft: A software package for liquid argon time projection drift
chambers (2014).

[246]
S.J. Reddi, S. Kale, et al., in International Conference on Learning
Representations (2018).

[247]
S.S. Channappayya, A.C. Bovik, et al., IEEE Transactions on Image Processing
17(6), 857 (2008).

[248]
Z. Wang, A.C. Bovik, IEEE Signal Processing Magazine 26(1), 98 (2009).

[249]
H. Zhao, O. Gallo, et al.
Loss functions for neural networks for image processing (2018).

[250]
M. Rossi.
Slicing with dl models at protodune-sp (2021).

[251]
J.S. Marshall, M.A. Thomson, Eur. Phys. J. C 75(9), 439 (2015).

[252]
M.A. Thomson, Nucl. Instrum. Meth. A 611, 25 (2009).

[253]
J.S. Marshall, A. Münnich, M.A. Thomson, Nucl. Instrum. Meth. A 700,
153 (2013).

[254]
R. Acciarri, C. Adams, et al., Eur. Phys. J. C 78(1), 82 (2018).

[255]
M. Antonello, et al., Adv. High Energy Phys. 2013, 260820 (2013).

[256]
A. Scarpelli, in Proceedings of Neutrino Oscillation Workshop
— PoS(NOW2018), vol. 337 (2019), vol. 337, p. 036.

[257]
S. Ruder.
An overview of gradient descent optimization algorithms (2017).

CHAPTER: LIST OF PUBLICATIONS

tocchapterList of Publications
As of August 27, 2024

Refereed publications

PDFFlow: parton distribution functions on
GPU [184].

MadFlow: automating Monte Carlo simulation on GPU for particle physics processes [209].

Deep Learning Strategies for ProtoDUNE Raw Data
Denoising [219].

Publications under review

Slicing with deep learning models at ProtoDUNE-SP [250].
Proceedings of 20th International Workshop on Advanced Computing and Analysis
Techniques in Physics Research — ACAT 2021[Article already
accepted by the editor. The proceedings book has not been issued yet.].

Publications in conference proceedings

PDFflow: hardware accelerating parton density access [185].
Proceedings of 40th International Conference on High Energy physics
— PoS(ICHEP2020).

MadFlow: towards the automation of Monte Carlo simulation on GPU for
particle physics processes [208]. Proceedings of 25th
International Conference on Computing in High Energy and Nuclear Physics
— CHEP 2021.

[LO]List of Publications
[RE]List of Publications

CHAPTER: ACKNOWLEDGMENTS

The thesis work has been done in cooperation with the University of Milan and
CERN openlab groups.

The research has been funded and supported by the IBM Power Development group,
that also provided hardware and intellectual contribution.

Several people contributed to the realization of the present work. A huge thank
you to them who have made this possible.

To the supervisors Stefano Carrazza and Sofia Vallecorsa for their precious
guidance during the whole journey.

To Eric Aquaronne, that has always been present to organize and sponsor the
work throughout the IBM company.