betaFeedback

WorksPhysics and Astronomy

CaloPointFlow II Generating Calorimeter Showers as Point Clouds

Abstract

The simulation of calorimeter showers presents a significant computational challenge, impacting the efficiency and accuracy of particle physics experiments. While generative ML models have been effective in enhancing and accelerating the conventional physics simulation processes, their application has predominantly been constrained to fixed detector readout geometries. With CaloPointFlow we have presented one of the first models that can generate a calorimeter shower as a point cloud. This study describes CaloPointFlow II, which exhibits several significant improvements compared to its predecessor. This includes a novel dequantization technique, referred to as CDF-Dequantization, and a normalizing flow architecture, referred to as DeepSet- Flow. The new model was evaluated with the fast Calorimeter Simulation Challenge (CaloChallenge) Dataset II and III.

Introduction

Accurately simulating particle interactions in detectors is a fundamental part of modern high-energy physics (HEP) experiments, such as those performed at the Large Hadron Collider (LHC). These simulations are essential for physicists to produce data that can be compared with experimental results, aiding in the search for new physics phenomena or in making more precise measurements of known physical properties. The planned high luminosity upgrade of the LHC [1] will see experimental data taken at more and more increasing rates, presenting significant challenges for coping with the simulation needs. Among the various components of a detector, calorimeters are especially demanding in simulation. Calorimeters are used to measure the energy of incoming particles by detecting the cascade of secondary particles they produce. To simulate these processes, detailed and complex multistep computations are necessary.

Conventionally, simulations such as Geant4 [2] are employed to accurately replicate these intricate interactions. While these methods offer unmatched accuracy, they are computationally intensive, often requiring seconds per event on a conventional CPU. This high computational demand creates a bottleneck, especially as we move into an era of high-luminosity experiments that will produce larger volumes of data, feature more complex detector geometries, and demand simulations of unprecedented scale and quality. Moreover, the projected computing budgets at large experiments are difficult to reconcile with the increasing amount of simulated events needed, given the current capabilities of Monte Carlo simulations [3, 4]. The detailed simulations consume a significant portion of the computational budget in many large-scale experiments, further sharpening the challenge.

Given these constraints, it is increasingly impossible to run full, detailed detector simulations for each event to be simulated. The use of fast simulation methods is on the rise, as they approximate high-fidelity simulations while occupying less computational power. However, conventional fast simulation frameworks, which are mostly based on parametric models [5, 6, 7, 8, 9, 10, 11, 12, 13, 14], often fail to capture subtle details of calorimeter interactions. This lack of precision can lead to discrepancies in results when performing physics analyses, which emphasizes the need for a more efficient, yet accurate, alternative.

To tackle these challenges, there is an increasing effort to develop generative machine learning models as a more computationally efficient yet accurate method for calorimeter simulation. The objective is to develop models that can precisely reproduce the distribution of calorimeter responses while significantly reducing computational time and resources. Such an approach not only reduces the burden on the computational infrastructure, but also has the potential to enable more intricate and precise analyses than those currently feasible.

To address these aspects, there is a growing field of research about deep learning based surrogate models [15, 16, 17, 18, 19, 20, 21, 22, 23, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50] such as Generative Adversarial Networks (GANs) [15, 16, 17, 18, 19, 20, 21, 22, 23, 23, 26, 27, 36, 39, 40, 48, 49], Variational Autoencoders (VAEs) [21, 26, 33, 45], normalizing flows [24, 25, 31, 34, 35, 43, 45, 46], and diffusion models [28, 29, 37, 38, 41, 42, 47, 50], that have been developed for detector simulations. These models replicate the output of traditional simulations, such as Geant4, and are designed to emulate the complex interactions of particles within calorimeters. This is achieved with significantly fewer computational resources. This progress is particularly important in high-energy physics (HEP) experiments, as it not only mitigates computational bottlenecks but also enables more comprehensive and detailed investigations.

Most of these models are based on a fixed data geometry, where a calorimeter is represented by a collection of voxels. Each voxel corresponds to a single calorimeter sensor. High granular calorimeters are composed of several million sensor cells. For example, the proposed upgrade for the CMS Calorimeter, known as the HGCAL [51], is expected to feature around 6 million sensor cells. However, it is commonly observed that particle showers deposit their energy in only a small portion of the total number of cells, resulting in a sparsely populated voxel representation.

Therefore, it is more efficient to model the distribution of hits, which represent the locations where energy is actually deposited, rather than attempting to represent every single cell. These ’hits’ can be conceptualized as points in a four-dimensional space, combining three spatial dimensions with an additional energy component. The number of points detected by the calorimeter corresponds to the total number of hits.

This approach is consistent with previous studies in particle physics that have investigated generative models based on point clouds [34, 37, 38, 41, 49, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62]. Previous research has also explored the use of these models for calorimeter simulations [34, 37, 38, 41, 49].

We have developed CaloPointFlow, one of the first point cloud-based surrogate models specifically designed for calorimeter simulation [34]. Building on this model, we present here the advanced version of the original model, which we have named CaloPointFlow II1. CaloPointFlow II has been tailored for the Fast Calorimeter Simulation Challenge (CaloChallenge) [63], and incorporates several significant updates compared to the original CaloPointFlow architecture. They are described below:

  1. A major boost in CaloPointFlow II is the introduction of a novel dequantization technique, called CDF-Dequantization. This technique is a solution to the common problems in dequantization, ensuring that the marginal distributions are normally distributed.

  1. Another major development in CaloPointFlow II is the creation of a new Normalizing Flow architecture, referred to as DeepSetFlow. This architecture allows the modeling of point-to-point correlations. Such correlations were difficult to capture in the previous model, but DeepSetFlow overcomes this limitation.

  1. In addition, CaloPointFlow II leverages the rotational symmetry inherent in the datasets. This method mitigates the ”multiple hit” problem, which has been a notable obstacle in accurately simulating the behavior of showers within calorimeters.

Our paper is structured as follows. First, we describe the datasets used in § 2. Then we describe our model in § 3 and briefly line out our pre- and post-processing in § 4. Next, we introduce CDF-Dequantization in § 5. In § 6 we explain details of DeepSetFlow and in § 7, we describe our mitigation strategy for the multiple hit problem. In § 8 we present the results and evaluate the model. Finally, we summarize the paper with conclusions in § 9.

Datasets

In our research, we exclusively use the second and third dataset from the CaloChallenge [63]. Each shower in the dataset contains the incident energy of the incoming particle and a vector containing the voxel energies. The incident energy EincE_{\mathrm{inc}} is log-uniformly distributed between 11 GeV and 11 TeV. Each dataset consists of 200,000 showers initiated by electrons. These datasets are equally divided for training and evaluation purposes.

Datasets 2 [64] and Dataset 3 [65] are simulated using the same physical detector, which consists of concentric cylinders with 90 layers of absorber and sensitive (active) materials, specifically tungsten (W) and silicon (Si), respectively. Each sub-layer consists of 1.41 mm of W and 0.31 mm of Si, resulting in a total detector depth of 1531 mm. The detector’s inner radius is 801 cm.

The readout segmentation is determined by the direction of the particle entering the calorimeter. This direction defines the zz-axis of the cylindrical coordinate system, with the entrance position in the calorimeter set as the origin (0,0,0)(0, 0, 0). The voxels (readout cells) in both datasets 2 and 3 have identical sizes along the zz-axis but differ in segmentation in radius (r) and angle (α\alpha).

For the zz-axis, the voxel size is 3.4mm, corresponding to two physical layers (W-Si-W-Si). Considering only the absorber value of the radiation length 1X0(W)=3.50411 X_0(W) = 3.5041 mm, the zz-cell size equates to 2×1.41 mm3.5041 mm=0.81X02 \times\frac{1.41\ \mathrm{mm}}{3.5041\ \mathrm{mm}} = 0.81 X_0. In the radial dimension, the cell sizes are 2.3251 mm for dataset 3 and 4.651 mm for dataset 2. Approximately, considering the Molière radius of Tungsten (W) only, this corresponds to 0.251 RmR_{\mathrm{m}} for dataset 3 and 0.51 RmR_{\mathrm{m}} for dataset 2. The minimum energy threshold for the readout per voxel in datasets 2 and 3 is set to 15.15keV.

The calorimeter geometry of Dataset 2 comprises 45 concentric cylindrical layers stacked along the direction of particle propagation (zz). Each layer is further divided into 16 angular bins (α\alpha) and nine radial bins (r), resulting in a total of 45×16×9=648045 \times16 \times9 = 6480 voxels.

Dataset 3 from the CaloChallenge features a higher granularity compared to Dataset 2. Each layer in Dataset 3 consists of 18 radial bins and 50 angular bins, resulting in a total of 45×50×18=4050045 \times50 \times18 = 40500 voxels.

For both datasets, we adhered to the CaloChallenge’s specifications by dividing the available events equally between training and evaluation.

Model

The model presented in this section is a continued development from our previous model [34]. It is evolved from the basics of the PointFlow model, which was introduced by Yang et al. [66].

The target of the model is to generate point clouds with the probability density p(X)p(X), where XX are the possible showers. The schematic layout of the data flow in the training process can be seen in Figure 1a. The model is considered a variational autoencoder (VAE) [67], with the PointFlow serving as the decoder and the LatentFlow transforming the encoded distribution. To train the model, the Evidence Lower Bound (ELBO) is maximized. The encoder qϕ(z∣X)q_\phi(z|X) and decoder pθ(X∣z)p_\theta(X|z) can be trained simultaneously over the probability distribution of the latent variable p(z)p(z) with this loss-function

Figure 1. A schematic view of the model. Part a) displays the training setup. The Encoder encodes the points into the latent representation zz. The LatentFlow is optimized to learn zz, while the PointFlow is optimized to learn the distribution of points xix_i conditioned on zz. Part b) displays the sampling setup. First, the conditional variables EsumE_{\mathrm{sum}} and nhitsn_{\mathrm{hits}} are generated. Then, the LatentFlow generates the latent representation zz, which is used to generate the points with the PointFlow.

L=Eqϕ(z∣X)[ln⁡pθ(X∣z,C)]−DKL(qϕ(z∣X)∣∣p(z∣C))(1)\mathcal{L} = \mathbb{E}_{q_\phi(z|X)}[\ln p_\theta(X|z,\mathcal{C})] - D_{KL}(q_\phi(z|X)||p(z|\mathcal{C})) \tag*{(1)}
=Eqϕ(z∣X)[ln⁡pθ(X∣z,C)]⏟Lrecon+Eqϕ(z∣X)[ln⁡pθ(z∣C)]⏟Lprior−H(qϕ(z∣X)).(2)\begin{aligned} &= \underbrace{\mathbb{E}_{q_\phi(z|X)}[\ln p_\theta(X|z,\mathcal{C})]}_{\mathcal{L}_{\mathrm{recon}}} + \underbrace{\mathbb{E}_{q_\phi(z|X)}[\ln p_\theta(z|\mathcal{C})]}_{\mathcal{L}_{\mathrm{prior}}} - \mathcal{H}(q_\phi(z|X)). \tag*{(2)} \end{aligned}

The loss-function consists of three parts. The first part Lrecon\mathcal{L}_{\mathrm{recon}} is the reconstruction error of the shower XX. Minimizing Lrecon\mathcal{L}_{\mathrm{recon}} is equal to generating hits of the shower with a high likelihood. The second part Lprior\mathcal{L}_{\mathrm{prior}} is the expectation value of the prior distribution obeying the approximated distribution of the encoder. Minimizing Lprior\mathcal{L}_{\mathrm{prior}} is equal to generating a latent vector zz with a high probability. The last term H(qϕ(z∣X))\mathcal{H}(q_\phi(z|X)) is the entropy of the encoded values. It is a regularization on the latent space zz.

Here the encoder qϕ(z∣x)q_\phi(z|x) approximates zz conditioned on XX. To efficiently optimize the ELBO, sampling from qϕ(z∣x)q_\phi(z|x) is done by reparametrizing zz as z=μϕ(X)+σϕ(X)⋅ϵz = \mu_\phi(X) + \sigma_\phi(X) \cdot\epsilon, where ϵ∼N(0,1)\epsilon\sim\mathcal{N}(0,1).

Since we approximate the prior pθ(X)p_\theta(X) as locally normal distributed, the entropy is given by

H(qφ(z∣X))=d2(1+ln⁡(2π))+∑i=1dln⁡σi.(3)\mathcal{H}(q_{\varphi}(z \mid X)) = \frac{d}{2}(1+\ln(2\pi))+\sum_{i=1}^{d}\ln\sigma_i. \tag*{(3)}

To model a more complex latent distribution p(z)p(z), the latent space zz is transformed by the LatentFlow. The LatentFlow consists of multiple neural spline coupling layers [68] that transform the distribution to a normal distribution. Therefore, the expectation value of the prior distribution can be written as

Lprior=Eqφ(z∣X)[ln⁡p(f−1(z,C))+ln⁡∣det⁡df−1(z,C)dz∣].(4)\mathcal{L}_{\mathrm{prior}} = \mathbb{E}_{q_{\varphi}(z \mid X)}\left[\ln p(f^{-1}(z,C))+\ln\left|\det\frac{\mathrm{d}f^{-1}(z,C)}{\mathrm{d}z}\right|\right]. \tag*{(4)}

The conditional probability density of the entire shower is approximated by the PointFlow, which is implemented as a DeepSetFlow, described in § 6.

Lrecon=Eqφ(z∣X)[ln⁡p(g−1(X,z,C))+ln⁡∣det⁡dg−1(X,z,C)dX∣].(5)\mathcal{L}_{\mathrm{recon}} = \mathbb{E}_{q_{\varphi}(z \mid X)}\left[\ln p(g^{-1}(X,z,C))+\ln\left|\det\frac{\mathrm{d}g^{-1}(X,z,C)}{\mathrm{d}X}\right|\right]. \tag*{(5)}

A schematic view of the sampling process is shown in Figure 1b. For each shower, first EsumE_{\mathrm{sum}} and nhitsn_{\mathrm{hits}} are sampled by the CondFlow. A latent vector zz is sampled by the LatentFlow. At last, nhitsn_{\mathrm{hits}} points are generated by the PointFlow.

Pre- and Post-Processing

We transform the voxel based datasets to point cloud datasets. Each shower is represented by a combination of the coordinates ((zz, α\alpha, rr)) and the energy (ee) of all voxels for which e>0e > 0. To normalize the showers, we divide each energy value ee by the sum of all energies in the shower EsumE_{\mathrm{sum}}. The energy fraction is min-max-scaled and transformed with the logit function.

For the coordinates, we remove the α\alpha-component, for further information, see § 7. We dequantize zz and rr with the CDF-Dequantization, described in § 5.

The conditional variables cc consists of the transformed number of hits nhitsn_{\mathrm{hits}} and EsumE_{\mathrm{sum}}

c=(ln⁡(nhits+ϵ)/EinEsum/Ein)(6)c=\begin{pmatrix} \ln(n_{\mathrm{hits}}+\epsilon)/\sqrt{E_{\mathrm{in}}}\\ E_{\mathrm{sum}}/E_{\mathrm{in}} \end{pmatrix} \tag*{(6)}

Here EinE_{\mathrm{in}} is the energy of the initial electron and the number of hits is dequantized by adding ϵ∼U(0,1)\epsilon\sim U(0,1).

Both, cc and the transformed calorimeter hits are normalized to have a mean of 0 and a standard deviation of 1.

For sampling, we revert the transformation applied above to the generated points and conditional variables. The α\alpha-component is reintroduced, as explained in § 7.

CDF-Dequantization

Normalizing flows are invertible transformations utilized in machine learning to map probability distributions to the normal distribution, primarily designed for continuous data. The application to discrete data, however, includes complexities.

Transforming discrete data into continuous ones is called dequantization. For the new model we developed a novel method called CDF-Dequantization, which utilizes the inverse transform method, or Smirnov transform, to map any finite discrete one dimensional distribution to a normal distribution. We split the transformation in two parts. The first is a mapping to the uniform distribution between 0 and 1, here denoted as UU. The second is a mapping from UU to the normal distribution N\mathcal{N}.

Conventionally, dequantization involves the addition of uniformly distributed noise, as proposed by Uria et al. [69], and subsequent scaling of discrete values to form a continuous-space dataset. The inverse of this process combines a back scaling operation with a floor operation. This method of dequantization assigns densities over hypercubes around data points, an essential step to prevent the density model from approximating a degenerate mixture of point masses.

However, modeling such hypercubes with smooth function approximators poses significant challenges. To overcome this, Ho et al. [70] introduced variational dequantization. Rather than assigning uniform noise, this technique incorporates an additional normalizing flow that learns and applies a structured, non-uniform noise to the data, effectively increasing the modeling complexity.

Dinh et al. [71] added another dimension to dequantization. They proposed applying a logit transformation to the dequantized variables, transforming the support from the interval [0,1][0,1] to (−∞,∞)(-\infty,\infty).

The logit transformation, when applied to u∼Uu \sim U, maps to a logistic distribution. The challenge imposed to the normalizing flow is then to learn to convert this logistic distribution into a normal distribution, a task complicated by substantial differences in the distributions’ tails. For further details, please refer to Appendix § 11.

Transforming a uniform distribution into any distribution causes a noteworthy problem in the domain of statistics and data science. One solution is using the inverse transform

ΦX−1(u)=inf⁡{x∣FX(x)≥u}.\Phi_X^{-1}(u) = \inf\{x|F_X(x) \ge u\}.

This transform maps U→XU \to X, where XX is any distribution. A proof for the case of a continuous distribution is provided in Appendix § 12 or can be found in the statistics literature.

For our current focus, we are interested in mapping the standard uniform distribution onto the normal distribution, and also being able to reverse this process. To define these mappings, we rely on the cumulative distribution function (CDF) and its inverse, the quantile function. The CDF of a standard normal distribution, denoted N\mathcal{N}, is given by

FN(x)=12[1+erf⁡(x2)],(7)F_{\mathcal{N}}(x) = \frac{1}{2}\left[1+\operatorname{erf}\left(\frac{x}{\sqrt{2}}\right)\right], \tag*{(7)}

where erf⁡(x)\operatorname{erf}(x) is the error function. This function provides the probability that a random variable from a standard normal distribution is less than or equal to xx. Conversely, the quantile function of the standard normal distribution, often referred to as the probit function, is

FN−1(y)=2erf⁡−1(2y−1).(8)F_{\mathcal{N}}^{-1}(y) = \sqrt{2}\operatorname{erf}^{-1}(2y-1). \tag*{(8)}

where erf⁡−1(x)\operatorname{erf}^{-1}(x) is the inverse error function. This function returns the value corresponding to a given probability yy, such that the probability of a random variable from a standard normal distribution being less than or equal to this value is yy.

It is important to note that exact evaluations of the CDF and its inverse for the normal distribution are computationally expensive. However, approximations to these functions can be found in most numerical software libraries, making it efficient to perform the mapping between the uniform and normal distributions.

Let us extend our previous discussions to the scenario where we require a mapping from a given discrete probability distribution to the standard uniform distribution. To achieve this, we need to establish the validity of the inverse transform for discrete distributions. A proof is given in Appendix § 13.

The Smirnov transform gives us an approach to map the standard uniform distribution U(0,1)U(0,1) to a discrete distribution by creating a decomposition of the interval [0,1][0,1] into nn sub-intervals, each having a size equivalent to the corresponding probability pip_i.

This forms a surjective mapping where intervals in [0,1][0,1] are associated with specific discrete values. Notably, Nielsen et al. [72] illustrated how variational autoencoders (VAEs), normalizing flows, and surjective mappings can be integrated into one unified framework. They have shown that surjective mappings can be used if a sufficient stochastic inverse is found.

Within this framework, Nielsen et al. have shown that the act of adding uniform noise can be interpreted as a stochastic inverse of the floor operation, denoted as ⌊x⌋\lfloor x \rfloor. This implies that p(x∣z)=δx,⌊z⌋p(x|z)=\delta_{x,\lfloor z\rfloor}. Its stochastic inverse, q(z∣x)q(z|x), has support in B(x)={x+u∣u∈[0,1]}\mathcal{B}(x)=\{x+u|u\in[0,1]\}.

In the context of CDF-Dequantization, the density p(xi∣u)=δ(FX(xi)≤u≤FX(xi+1))p(x_i|u)=\delta(F_X(x_i)\leq u\leq F_X(x_{i+1})) is a delta function that triggers if uu lies in the interval [FX(xi),FX(xi+1)][F_X(x_i),F_X(x_{i+1})]. Its stochastic inverse, q(u∣xi)q(u|x_i), is supported over

B={u∣FX(xi)≤u≤FX(xi+1)}(9)\mathcal{B}=\{u|F_X(x_i)\leq u\leq F_X(x_{i+1})\} \tag*{(9)}
={FX(xi)+u∣0≤u≤FX(xi+1)−FX(xi)}(10)=\{F_X(x_i)+u|0\leq u\leq F_X(x_{i+1})-F_X(x_i)\} \tag*{(10)}
={FX(xi)+u∣0≤u≤pi}(11)=\{F_X(x_i)+u|0\leq u\leq p_i\} \tag*{(11)}
={FX(xi)+u⋅pi∣u∈[0,1]}(12)=\{F_X(x_i)+u\cdot p_i|u\in[0,1]\} \tag*{(12)}

For our mapping to be accurate, the distribution of uu values should be uniform across [0,1][0,1]. Therefore, we can compose the stochastic mapping as ΦX(xi)=FX(xi)+u⋅pi\Phi_X(x_i)=F_X(x_i)+u\cdot p_i where u∼U(0,1)u\sim U(0,1).

If we have access to all pip_i, this transformation provides a straightforward mapping from discrete data to a uniform distribution. The inverse transform can be found through a simple search across the probability intervals. We can simply approximate pip_i by counting the frequencies of xix_i in the data.

In summary, we have constructed a relatively simple transformation that can map discrete data to a normal distribution. In doing so, we have significantly eased the task of the normalizing flow, which is now left with only the responsibility to learn the correlations in the data and not the general shape. This enhances the efficiency and effectiveness of machine learning models dealing with discrete data. For a visual representation, see Figure 2 We provide the algorithms for both directions of the CDF-Dequantization below.

Figure 2. A schematic of the CDF-Dequantization

Algorithm 1 Forward Transformation (X→N)(X \to\mathcal{N})

for xi∈Xx_i \in X do     sample u∼U(0,1)u \sim U(0,1)     yi=FN−1(CDF⁡(xi)+PDF⁡(xi)⋅u)y_i = F_{\mathcal{N}}^{-1}(\operatorname{CDF}(x_i) + \operatorname{PDF}(x_i) \cdot u) end for Return Y={y1…yn}Y = \{y_1 \ldots y_n\}

Algorithm 2 Inverse Transformation (N→X)(\mathcal{N} \to X)

for yi∈Yy_i \in Y do     ui=FN(yi)u_i = F_{\mathcal{N}}(y_i)     xi=find first CDF≥uix_i = \text{find first CDF} \ge u_i end for Return X={x1…xn}X = \{x_1 \ldots x_n\}

This dequantization strategy is universal. For our CaloPointFlow II model we apply it to both the rr and zz dimensions of the points. The method treats each dimension independently and is thereby only altering the marginal distributions.

DeepSetFlow

The previous version of PointFlow utilized a system of coupling blocks to transform the features of points. This system divided the features into two equal parts, with one half undergoing transformation based on the other half. While permutation invariant and capable of handling varying cardinality, it lacked a mechanism for enabling information exchange among the points, resulting in an inability to model inter-point correlation.

To address this, we introduce a new Normalizing Flow architecture called DeepSetFlow. The architecture integrates DeepSets [73] in each coupling layer. In the coupling layer, the part of all point features that is not further transformed is aggregated into a latent representation. The per-point transformation uses the latent representation as another conditional feature.

Graphically, our architecture resembles a central node that gathers information from all nodes. It distributes the information evenly and is linear in the number of points.

The new flow architecture is able to capture the point-to-point correlations. This approach shares similarities with previous work by Buhmann et al. [52] who constructed the EPiC-GAN, a model that applied DeepSets to create a permutation equivariant generative model. Mikuni et al. [55] also employed a similar technique of information aggregation within a diffusion model to learn point clouds.

In another instance, Käch et al. [54] developed a model that combines all information into a single node, referred to as the mean field. Their model’s main distinguishing factor from previous ones is the use of cross attention to update the information of the mean field.

Finally, Liu et al. [74] crafted a Graph Normalizing Flow. In creating a coupling layer for graphs, they suggested the same feature-splitting across points as in our model.

Multiple Hit Workaround

The dataset consists of voxels, thus only one hit per calorimeter cell is allowed. Point cloud-based models, however, generate points in continuous space and inherently have no limitation that only one point can exist within the space of a cell. Therefore, the model often produces multiple points per calorimeter cell, which is incompatible with the data. So far, no adequate solution to this problem is known and we have developed a novel approach to solve this problem.

We make use of the rotational symmetry of the calorimeter and generate the points without an α\alpha-component. We distribute the points randomly in α\alpha, and if there are more points than cells, these are randomly added to the occupied α\alpha-positions. Here, we assume that there is no internal shower structure in α\alpha. This is, of course, fundamentally incorrect. However, in our experiments, it improves the modelling of the electron showers.

Results

In this section, we assess the model’s performance by comparing the generated showers with those simulated by Geant4, using data that was not used in training. If not stated otherwise, we compare histograms of distributions in the figures below. The red dashed lines represent the original Geant4 data, while the blue lines represent the distribution produced by the CaloPointFlow II model. To provide a clearer perspective, smaller plots are included below each main figure, where the difference between the two distributions is expressed as a ratio.

Figure 3 shows the distribution of the sum of all energies in the calorimeter cells divided by the energy of the initial particle. A good agreement between Geant4 and CaloPointFlow II is concluded from this comparison.

Figure 3. The distribution of the sum of all energies in the calorimeter divided by the energy of the incident electron (left) for Dataset II and (right) for Dataset III.

In Figure 4 we present the energy distributions of individual cells in the two different datasets. These figures show consistency within the bulk of the distributions across both datasets. However, one observation can be made regarding the tails of these distributions. In both cases, the CaloPointFlow II model shows a tendency to overshoot or undershoot in energy. This phenomenon is particularly pronounced in Dataset III, where the deviations from the expected values are more pronounced in the tail regions.

Figure 4. The distribution of cell energies (left) for Dataset II and (right) for Dataset III.

Figure 5 shows the distribution of the number of hits in both data sets. The ”number of hits” is defined as the number of calorimeter cells that have an energy value greater than zero for a given shower. A key observation in both datasets is the generally accurate modeling of the overall distribution of hits. However, a closer examination of Figure 5 reveals a limitation in the models ability to reproduce the highest number of hits. This problem is most likely due to the multiple hits workaround. In scenarios where most detector cells are hit, the probability of mapping multiple points to a single cell increases significantly. This results in a discrepancy in the tail of the distribution, where the model fails to generate the extreme values observed in the real data. Conversely, for Dataset III this particular problem is not apparent. This dataset is characterized by a smaller proportion of total cells being hit. This observation suggests that the problem of accurately modeling the highest number of hits is less pronounced in more granular calorimeters.

Distribution of number of hits for Dataset II and Dataset III

Figure 5. The distribution of number of hits (left) for Dataset II and (right) for Dataset III.

Figure 6 shows the marginal profiles of the average shower for the second and third data sets, respectively. Figure 6 (left) shows the longitudinal shower profile. We observe minimal variation between the two distributions, indicating a strong agreement in the longitudinal profile. In Figure 6 (middle) the flat distribution of α\alpha is visible. Both distributions appear to be uniformly flat, which is an inherent property of the construction. Finally, Figure 6 (right) both figures examines the radial distribution, where we find that both distributions have similar decreasing structure.

Figure 6. The marginal profiles of the average shower shapes in zz, α\alpha and rr (top) for Dataset II and (bottom) for Dataset III.

Figure 7 provides a detailed view of the distribution of the total energy in different areas of the detector. For each dataset, five plots are shown with the energy distribution in five successive layers of the detector. A consistent pattern observed in these figures is the accurate modeling of the energy distributions in the initial layers of the detector. However, there is a notable discrepancy in the rear layers. In these layers, there is a significant absence of higher energy values in the model results.

Figure 7. The energy distribution in different layers of the detector (top) for Dataset II and (bottom) for Dataset III.

Figure 8 contains the Pearson correlation coefficients, which quantify the relationships between the energies of all cells in the detector. For visualization purposes, the three-dimensional structure of the detector is flattened, resulting in a recurring pattern within the displayed data. Figure 8 (left) shows the energy distribution as simulated by Geant4, Figure 8 (middle) illustrates the results from the CaloPointFlow II model, and Figure 8 (right) highlights the differences between the two models. A key observation is the overall effective modeling of the correlation coefficients by the CaloPointFlow II model. This suggests that the model is able to capture the inter-cell energy relationships within the detector.

Pearson correlation coefficients between all detector cells for Dataset II and Dataset III

Figure 8. The Pearson correlation coefficients between all cells of the detector are displayed (top) for Dataset II and (bottom) for Dataset III.

Figure 9 shows the energy-weighted mean of the shower in Dataset II and III, respectively. The means μi\mu_i are calculated as

Figure 9. Energy-weighted shower center distribution in all three dimensions (top) for Dataset II and (bottom) for Dataset III.

μi=∑jcji⋅eji∑jeji(13)\mu_i = \frac{\sum_j c_j^i \cdot e_j^i}{\sum_j e_j^i} \tag*{(13)}

where cjic_j^i are the 3-dimensional coordinate vector of the hit constituents of the shower and ejie_j^i are the corresponding energies. The modeled showers capture the general trend of the energy-weighted mean, but there are some discrepancies with the actual data. These differences may indicate limitations in the model’s ability to accurately simulate the nuanced distribution of energy within the showers.

To further explore the structure of the showers in Figure 10, we compute the energy-weighted covariance matrix for each shower. This is done by first determining the deviation of each cell position vector cjic_j^i from the mean position vector μi\mu_i of the shower. This deviation is denoted as c^ji=cji−μi\hat{c}_j^i = c_j^i - \mu_i. The energy-weighted covariance matrix CikC_{ik} is then computed using the formula

Figure 10. The eigenvalues of the covariance matrix weighted by energy are presented (top) for Dataset II and (bottom) for Dataset III.

Cik=∑jeji(c^ji)T⋅c^ji∑jeji−1.(14)C_{ik} = \frac{\sum_j e_j^i(\hat{c}_j^i)^{T} \cdot\hat{c}_j^i}{\sum_j e_j^i - 1}. \tag*{(14)}

This matrix represents the spread and orientation of the shower in the detector space, energy-weighted. After computing these matrices, we decompose them to extract their eigenvalues. These eigenvalues, which represent the principal components of the showers spread in three dimensions, are then plotted to analyze their distribution.

In analyzing these distributions, we observe a notable contrast between the two datasets. For Dataset II, there is good agreement between the model and the actual data, indicating that the model effectively captures the spatial structure of the showers in this dataset. For Dataset III, however, the discrepancies are more pronounced.

The performance of the official CaloChallenge classifier is evaluated in Table 1. The classifier is applied ten times to each dataset and model. The evaluation shows that the CaloPointFlow II model outperforms the CaloPointFlow I model in both low-level and high-level classifications across all datasets. This significant difference in performance highlights the advancements and improvements incorporated in the CaloPointFlow II model. For Dataset III, there is a noticeable trend where the low-level classifier is less effective for distinguishing between outcomes compared to the high-level classifier. It is

DatasetModellow level classifierhigh level classifier
AUCJSDAUCJSD
IICPF I0.945±0.0040.945 \pm0.0040.604±0.0140.604 \pm0.0140.927±0.0030.927 \pm0.0030.509±0.0080.509 \pm0.008
CPF II0.826±0.0060.826 \pm0.0060.275±0.0080.275 \pm0.0080.785±0.0090.785 \pm0.0090.220±0.0150.220 \pm0.015
IIICPF I0.786±0.0190.786 \pm0.0190.121±0.0220.121 \pm0.0220.947±0.0030.947 \pm0.0030.582±0.0100.582 \pm0.010
CPF II0.709±0.0400.709 \pm0.0400.107±0.0290.107 \pm0.0290.934±0.0030.934 \pm0.0030.530±0.0080.530 \pm0.008

caption: CaloChallenge Classifier Score for the CaloPointFlow I and CaloPointFlow II model.

:::

possible that further tuning or retraining of the model, with a focus on its handling of high-level features, could lead to further improvements.

Conclusion

In this study, we have introduced CaloPointFlow II, a refined generative model that significantly advances the simulation of calorimeter showers. The utilization of point clouds, owing to their inherent sparsity, offers a computationally more efficient approach compared to traditional fixed data structures like 3D images. Building upon the foundations of the original CaloPointFlow model, CaloPointFlow II incorporates innovative techniques such as a novel dequantization method, referred to as CDF-Dequantization, and a new normalizing flow architecture, named DeepSetFlow. These enhancements contribute to a more efficient and accurate modeling of particle interactions in calorimeters, enabling more efficient and accurate modeling of complex particle interactions.

The extensive evaluation of CaloPointFlow II using the challenging CaloChallenge datasets II and III has proven its efficacy. Our model not only exhibits superior performance in both low-level and high-level classifications compared to its predecessor but also showcases significant improvements in the accuracy of calorimeter shower simulations. The results demonstrate not only its capability to accurately simulate calorimeter showers, but also a marked improvement in computational efficiency compared to traditional methods. The model exhibits a balance between fidelity in the simulation and the computational demands, especially evident in the precise modeling of the spatial structure and energy distributions within calorimeter showers.

In comparison to other models, CaloPointFlow II shows notable advancements, particularly in terms of computational speed and accuracy. While there remain areas for further improvement, particularly in aligning the model’s output more closely with real-world data, the strides made with CaloPointFlow II are clear. Future work could involve exploring more sophisticated architectural designs for the model to enhance its performance further.

Furthermore, the upcoming CaloChallenge summary paper will provide a comprehensive comparison of CaloPointFlow II against other models.

Acknowledgements

The Deutsches Elektronen-Synchrotron DESY, a member of the Helmholtz Association (HGF), funded this research. The Maxwell computing resources operated at DESY were used to perform this research.

Logistic Distribution and Normal Distribution

Figure 11 shows that the tails of the normal distribution decrease significantly faster than the logistic distribution.

Figure 11. Comparison of the logarithmic declines of the logistic and normal distribution.

Proof Inverse Transformation for continuous distributions

Let’s consider XX as a random variable that has a cumulative distribution function (CDF) represented as FX(x)=P(X≤x)F_X(x)=P(X\leq x). The CDF of a random variable is an essential element in probability and statistics, as it provides the probability that a random variable will take a value less than or equal to a specific value.

By the properties of the CDF, we know that if x<yx<y, then FX(x)≤FX(y)F_X(x)\leq F_X(y), because the probability that XX is less than or equal to xx is always less than or equal to the probability that XX is less than or equal to yy. Moreover, FXF_X is strictly increasing where the probability density function PX(x)>0P_X(x)>0, indicating that the probability increases as the value of XX increases.

Now, let’s suppose that FXF_X is strictly increasing. Then, for any u∈(0,1)u\in(0,1), the equation F(x)=uF(x)=u has exactly one solution. We denote this solution as x=FX−1(u)x=F_X^{-1}(u), where FX−1F_X^{-1} is the inverse function of FXF_X. In such a situation, we can say that

FX−1(u)=inf⁡{x∣FX(x)≥u}=inf⁡{x∣FX(x)=u}=FX−1(u)(15)F_X^{-1}(u)=\inf\{x|F_X(x)\geq u\}=\inf\{x|F_X(x)=u\}=F_X^{-1}(u) \tag*{(15)}

This shows that the Smirnov transformation is essentially the inverse of the CDF, provided FXF_X is strictly increasing.

Furthermore, the inverse function FX−1F_X^{-1} is also strictly increasing on the interval (0,1)(0,1). This is because if FXF_X is strictly increasing, then the inverse function will also preserve this property.

Let’s now define a new random variable Y=FX−1(U)Y=F_X^{-1}(U). For this random variable, we can express the cumulative distribution function of UU as FU(FX(x))=P(U≤FX(x))=FX(x)F_U(F_X(x))=P(U\leq F_X(x))=F_X(x).

Given that FX−1F_X^{-1} is strictly increasing, we can proceed and apply this property to our inequality. Specifically, P(U≤FX(x))=P(FX−1(U)≤FX−1(FX(x)))P(U\leq F_X(x))=P(F_X^{-1}(U)\leq F_X^{-1}(F_X(x))). Since FX−1(FX(x))F_X^{-1}(F_X(x)) simplifies to xx, this can be re-written as P(FX−1(U)≤x)=P(Y≤x)=FY(x)P(F_X^{-1}(U)\leq x)=P(Y\leq x)=F_Y(x). Hence, we have derived that FY(x)=FX(x)F_Y(x)=F_X(x).

In conclusion, given these results and by the definition of the equality of random variables, we can say that X=YX=Y.

As we’ve established, the equality X=FX−1(U)X=F_X^{-1}(U) and its inverse U=FX−1(X)U=F_X^{-1}(X) provide an invertible mapping between the standard uniform distribution and any continuous distribution without gaps.

Proof Inverse Transformation for discrete distributions

Suppose XX is a discrete random variable with pi=P(X=xi)p_i=P(X=x_i) for i∈1,…,ni\in1,\ldots,n, where pip_i is the probability that XX equals xix_i and nn is the total number of possible outcomes. The cumulative distribution function FX(xn)F_X(x_n) is given by ∑inpi\sum_{i}^{n}p_i.

Let’s consider an arbitrary interval [a,b][a,b] such that 0≤a≤b≤10\leq a\leq b\leq1. In the standard uniform distribution, the probability that UU falls within this interval is

P(a≤U≤b)=P(U≤b)−P(U≤a)=b−a.(16)P(a \le U \le b) = P(U \le b) - P(U \le a) = b-a. \tag*{(16)}

Now, for all indices i<ji < j, we have 0≤FX(xi)≤FX(xj)≤10 \le F_X(x_i) \le F_X(x_j) \le1 due to the properties of the cumulative distribution function. Consequently, the probability that UU lies between FX(xi)F_X(x_i) and FX(xi+1)F_X(x_{i+1}) equals P(FX(xi)≤U≤FX(xi+1))=FX(xi+1)−FX(xi)=pi+1P(F_X(x_i) \le U \le F_X(x_{i+1})) = F_X(x_{i+1}) - F_X(x_i) = p_{i+1}. This probability is precisely the probability that the discrete random variable XX equals xi+1x_{i+1}.

Based on these results, we can construct the following function that acts as the inverse transform for the discrete distribution

ΦX−1(u)={x1,if U≤FX(x1)x2,if FX(x1)≤U≤FX(x2)⋮xn,if FX(xn−1)≤U≤FX(xn)(17)\Phi_X^{-1}(u) = \begin{cases} x_1, & \text{if } U \le F_X(x_1) \\ x_2, & \text{if } F_X(x_1) \le U \le F_X(x_2) \\ \vdots& \\ x_n, & \text{if } F_X(x_{n-1}) \le U \le F_X(x_n) \end{cases} \tag*{(17)}

In other words, ΦX−1(u)\Phi_X^{-1}(u) assigns the value xix_i to uu if it falls within the interval [FX(xi−1),FX(xi)][F_X(x_{i-1}), F_X(x_i)]. With this piece-wise defined function, we can express the inverse transform as

ΦX−1(u)=inf⁡{xi∣u≤FX(xi)}(18)\Phi_X^{-1}(u) = \inf\{x_i \mid u \le F_X(x_i)\} \tag*{(18)}

which provides us with the required mapping from the standard uniform distribution UU to the discrete random variable XX. Hence, we have successfully demonstrated the inverse transform method.

References

  1. [1]I. Zurbano Fernandez et al., High-Luminosity Large Hadron Collider (HL-LHC): Technical design report, CERN Yellow Reports: Monographs 10/2020 (2020), doi:10.23731/CYRM-2020-0010.
  2. [2]Geant4 Collaboration, Geant4 - a simulation toolkit, Nuclear Instruments and Methods in Physics Research Section A: Accelerators, Spectrometers, Detectors and Associated Equipment 506(3), 250 (2003), doi:10.1016/S0168-9002(03)01368-8.
  3. [3]J. Albrecht et al., A Roadmap for HEP Software and Computing R&D for the 2020s, Comput. Softw. Big Sci. 3(1), 7 (2019), doi:10.1007/s41781-018-0018-8, 1712.06982.DOI
  4. [4]A. Boehnlein, F. Simon, F. Hernandez et al., Hl-lhc software and computing review panel, 2nd report, Tech. rep., CERN (2022).
  5. [5]E. Barberio et al., Fast simulation of electromagnetic showers in the ATLAS calorimeter: Frozen showers, J. Phys. Conf. Ser. 160, 012082 (2009), doi:10.1088/1742-6596/160/1/012082.DOI
  6. [6]E. Barberio et al., Fast shower simulation in the ATLAS calorimeter, J. Phys. Conf. Ser. 119, 032008 (2008), doi:10.1088/1742-6596/119/3/032008.DOI
  7. [7]R. Rahmat and R. Kroeger, HF GFlash, Phys. Procedia 37, 340 (2012), doi:10.1016/j.phpro.2012.02.385.DOI
  8. [8]R. Rahmat, Performance of HFGFlash at CMS, EPJ Web Conf. 49, 18005 (2013), doi:10.1051/epjconf/20134918005.DOI
  9. [9]R. Rahmat, Upgrading HFGFlash for Faster Simulation at Super LHC, J. Phys. Conf. Ser. 513, 022031 (2014), doi:10.1088/1742-6596/513/2/022031.DOI
  10. [10]D. Jang, Parametrized simulation of the CMS calorimeter using GFlash, In 2009 IEEE Nuclear Science Symposium and Medical Imaging Conference, pp. 2074–2080, doi:10.1109/NSSMIC.2009.5402114 (2009).DOI
  11. [11]S.-Y. Jun, Gflash as a parameterized calorimeter simulation for the CMS experiment, J. Phys. Conf. Ser. 293, 012023 (2011), doi:10.1088/1742-6596/293/1/012023.DOI
  12. [12]G. Grindhammer and S. Peters, The Parameterized simulation of electromagnetic showers in homogeneous and sampling calorimeters, In International Conference on Monte Carlo Simulation in High-Energy and Nuclear Physics - MC 93 (1993), hep-ex/0001020.
  13. [13]K. Mahboubi and K. Jakobs, A fast parametrization of electromagnetic and hadronic calorimeter showers, Tech. rep., CERN, Geneva, All figures including auxiliary figures are available at https://atlas.web.cern.ch/Atlas/GROUPS/PHYSICS/PUBNOTES/ATL-SOFT-PUB-2006-001 (2005).
  14. [14]G. Grindhammer, M. Rudowicz and S. Peters, The Fast Simulation of Electromagnetic and Hadronic Showers, Nucl. Instrum. Meth. A 290, 469 (1990), doi:10.1016/0168-9002(90)90566-O.DOI
  15. [15]M. Paganini, L. de Oliveira and B. Nachman, Accelerating Science with Generative Adversarial Networks: An Application to 3D Particle Showers in Multilayer Calorimeters, Phys. Rev. Lett. 120(4), 042003 (2018), doi:10.1103/PhysRevLett.120.042003, 1705.02355.DOI
  16. [16]M. Paganini, L. de Oliveira and B. Nachman, CaloGAN : Simulating 3D high energy particle showers in multilayer electromagnetic calorimeters with generative adversarial networks, Phys. Rev. D97(1), 014021 (2018), doi:10.1103/PhysRevD.97.014021, 1712.10321.DOI
  17. [17]L. de Oliveira, M. Paganini and B. Nachman, Controlling Physical Attributes in GAN-Accelerated Simulation of Electromagnetic Calorimeters, J. Phys. Conf. Ser. 1085(4), 042017 (2018), doi:10.1088/1742-6596/1085/4/042017, 1711.08813.DOI
  18. [18]M. Erdmann, L. Geiger, J. Glombitza et al., Generating and refining particle detector simulations using the Wasserstein distance in adversarial networks, Comput. Softw. Big Sci. 2(1), 4 (2018), doi:10.1007/s41781-018-0008-x, 1802.03325.DOI
  19. [19]M. Erdmann, J. Glombitza and T. Quast, Precise simulation of electromagnetic calorimeter showers using a Wasserstein Generative Adversarial Network, Comput. Softw. Big Sci. 3(1), 4 (2019), doi:10.1007/s41781-018-0019-7, 1807.01954.DOI
  20. [20]D. Belayneh et al., Calorimetry with deep learning: particle simulation and reconstruction for collider physics, Eur. Phys. J. C 80(7), 688 (2020), doi:10.1140/epjc/s10052-020-8251-9, 1912.06794.DOI
  21. [21]E. Buhmann, S. Diefenbacher, E. Eren et al., Getting High: High Fidelity Simulation of High Granularity Calorimeters with High Speed, Comput.Softw.Big Sci. 5, 13 (2020), doi:10.1007/s41781-021-00056-0, 2005.05334.DOI
  22. [22]ATLAS Collaboration, Deep generative models for fast shower simulation in ATLAS, ATL-SOFT-PUB-2018-001 (2018).
  23. [23]G. Aad et al., Deep Generative Models for Fast Photon Shower Simulation in ATLAS, Comput. Softw. Big Sci. 8(1), 7 (2024), doi:10.1007/s41781-023-00106-9, 2210.06204.DOI
  24. [24]C. Krause and D. Shih, CaloFlow: Fast and Accurate Generation of Calorimeter Showers with Normalizing Flows, Phys.Rev.D 107, 113003 (2021), doi:10.1103/PhysRevD.107.113003, 2106.05285.DOI
  25. [25]C. Krause and D. Shih, CaloFlow II: Even Faster and Still Accurate Generation of Calorimeter Showers with Normalizing Flows, Phys.Rev.D 107, 113004 (2021), doi:10.1103/PhysRevD.107.113004, 2110.11377.
  26. [26]E. Buhmann, S. Diefenbacher, E. Eren et al., Hadrons, Better, Faster, Stronger, Mach.Learn.Sci.Tech. 3, 025014 (2021), doi:10.1088/2632-2153/ac7848, 2112.09709.DOI
  27. [27]G. Aad et al., AtlFast3: the next generation of fast simulation in ATLAS, Comput. Softw. Big Sci. 6, 7 (2022), doi:10.1007/s41781-021-00079-7, 2109.02551.DOI
  28. [28]V. Mikuni and B. Nachman, Score-based Generative Models for Calorimeter Shower Simulation, Phys.Rev.D 106, 092009 (2022), doi:10.1103/PhysRevD.106.092009, 2206.11898.DOI
  29. [29]V. Mikuni and B. Nachman, CaloScore v2: single-shot calorimeter shower simulation with diffusion models, JINST 19(02), P02001 (2024), doi:10.1088/1748-0221/19/02/P02001, 2308.03847.DOI
  30. [30]A. Adelmann et al., New directions for surrogate models and differentiable programming for High Energy Physics detector simulation, In 2022 Snowmass Summer Study (2022), 2203.08806.arxiv.org/abs/2203.08806
  31. [31]C. Krause, I. Pang and D. Shih, CaloFlow for CaloChallenge Dataset 1, arXiv preprint arXiv:2210.14245 (2022), 2210.14245.DOI
  32. [32]J. C. Cresswell, B. L. Ross, G. Loaiza-Ganem et al., CaloMan: Fast generation of calorimeter showers with density estimation on learned manifolds, In 36th Conference on Neural Information Processing Systems (2022), 2211.15380.arxiv.org/abs/2211.15380
  33. [33]A. Abhishek, E. Drechsler, W. Fedorko et al., CaloDVAE : Discrete Variational Autoencoders for Fast Calorimeter Shower Simulation, arXiv preprint arXiv:2210.07430 (2022), 2210.07430.arxiv.org/abs/2210.07430
  34. [34]S. Schnake, D. Krücker and K. Borras, Generating calorimeter showers as point clouds, https://ml4physicsalsciences.github.io/2022/files/NeurIPS_ML4PS_2022_77.pdf (2022).
  35. [35]S. Diefenbacher, E. Eren, F. Gaede et al., L2LFlows: Generating High-Fidelity 3D Calorimeter Images, JINST 18, P10017 (2023), doi:10.1088/1748-0221/18/10/P10017, 2302.11594.DOI
  36. [36]S. Diefenbacher, E. Eren, F. Gaede et al., New angles on fast calorimeter shower simulation, Mach. Learn. Sci. Tech. 4(3), 035044 (2023), doi:10.1088/2632-2153/acefa9, 2303.18150.DOI
  37. [37]E. Buhmann, S. Diefenbacher, E. Eren et al., CaloClouds: Fast Geometry-Independent Highly-Granular Calorimeter Simulation, JINST 18, P11025 (2023), doi:10.1088/1748-0221/18/11/P11025, 2305.04847.DOI
  38. [38]E. Buhmann, F. Gaede, G. Kasieczka et al., CaloClouds II: Ultra-Fast Geometry-Independent Highly-Granular Calorimeter Simulation, arXiv preprint arXiv:2309.05704 (2023), 2309.05704.arxiv.org/abs/2309.05704
  39. [39]H. Hashemi, N. Hartmann, S. Sharifzadeh et al., Ultra-High-Resolution Detector Simulation with Intra-Event Aware GAN and Self-Supervised Relational Reasoning, arXiv preprint arXiv:2303.08046 (2023), 2303.08046.DOI
  40. [40]J. Dubiński, K. Deja, S. Wenzel et al., Machine Learning methods for simulating particle response in the Zero Degree Calorimeter at the ALICE experiment, CERN, arXiv preprint arXiv:2306.13606 (2023), 2306.13606.arxiv.org/abs/2306.13606
  41. [41]F. T. Acosta, V. Mikuni, B. Nachman et al., Comparison of Point Cloud and Image-based Models for Calorimeter Fast Simulation, arXiv preprint arXiv:2307.04780 (2023), 2307.04780.arxiv.org/abs/2307.04780
  42. [42]O. Amram and K. Pedro, CaloDiffusion with GLaM for High Fidelity Calorimeter Simulation, Phys.Rev.D 108, 072014 (2023), doi:10.1103/PhysRevD.108.072014, 2308.03876.
  43. [43]I. Pang, J. A. Raine and D. Shih, SuperCalo: Calorimeter shower super-resolution, arXiv preprint arXiv:2308.11700 (2023), 2308.11700.
  44. [44]H. Hashemi and C. Krause, Deep Generative Models for Detector Signature Simulation: An Analytical Taxonomy, arXiv preprint arXiv:2312.09597 (2023), 2312.09597.
  45. [45]F. Ernst, L. Favaro, C. Krause et al., Normalizing Flows for High-Dimensional Detector Simulations, arXiv preprint arXiv:2312.09290 (2023), 2312.09290.DOI
  46. [46]M. R. Buckley, C. Krause, I. Pang et al., Inductive CaloFlow, arXiv preprint arXiv:2305.11934 (2023), 2305.11934.
  47. [47]S. Diefenbacher, V. Mikuni and B. Nachman, Refining Fast Calorimeter Simulations with a Schrödinger Bridge, arXiv preprint arXiv:2308.12339 (2023), 2308.12339.arxiv.org/abs/2308.12339
  48. [48]J. Erdmann, A. van der Graaf, F. Mausolf et al., SR-GAN for SR-gamma: photon super resolution at collider experiments, Eur.Phys.J.C 83, 1001 (2023), doi:10.1140/epjc/s10052-023-12178-3, 2308.09025.DOI
  49. [49]B. Käch, I. Melzer-Pellmann and D. Krücker, Pay attention to mean-fields for point cloud generation, https://ml4physicalsciences.github.io/2023/files/NeurIPS_ML4PS_2023_10.pdf (2023).arxiv.org/abs/2408.04997
  50. [50]D. Koblyanskii, N. Soybelman, E. Dreyer and E. Gross, CaloGraph: Graph-based diffusion model for fast shower generation in calorimeters with irregular geometry (2024), 2402.11575.
  51. [51]C. Collaboration, The Phase-2 Upgrade of the CMS Endcap Calorimeter, Tech. rep., CERN, doi:10.17181/CERN-IVsM.1JY2 (2017).DOI
  52. [52]E. Buhmann, G. Kasieczka and J. Thaler, EPiC-GAN: Equivariant Point Cloud Generation for Particle Jets, SciPost Phys. 15, 130 (2023), doi:10.21468/SciPostPhys.15.4.130, 2301.08128.DOI
  53. [53]B. Käch, D. Krücker and I. Melzer-Pellmann, Point Cloud Generation using Transformer Encoders and Normalising Flows, arXiv preprint arXiv:2211.13623 (2022), 2211.13623.arxiv.org/abs/2211.13623
  54. [54]B. Käch and I. Melzer-Pellmann, Attention to Mean-Fields for Particle Cloud Generation, arXiv preprint arXiv:2305.15254 (2023), 2305.15254.arxiv.org/abs/2305.15254
  55. [55]V. Mikuni, B. Nachman and M. Pettee, Fast Point Cloud Generation with Diffusion Models in High Energy Physics, Phys.Rev.D 108, 036025 (2023), doi:10.1103/PhysRevD.108.036025, 2304.01266.DOI
  56. [56]M. A. W. Scham, D. Krücker and K. Borras, DeepTreeGANv2: Iterative Pooling of Point Clouds, arXiv preprint arXiv:2312.00042 (2023), 2312.00042.arxiv.org/abs/2312.00042
  57. [57]M. A. W. Scham, D. Krücker, B. Käch et al., DeepTreeGAN: Fast Generation of High Dimensional Point Clouds, arXiv preprint arXiv:2311.12616 (2023), 2311.12616.arxiv.org/abs/2311.12616
  58. [58]R. Kansal, J. Duarte, H. Su et al., Particle Cloud Generation with Message Passing Generative Adversarial Networks, In 35th Conference on Neural Information Processing Systems (2021), 2106.11535.arxiv.org/abs/2106.11535
  59. [59]E. Buhmann, C. Ewen, D. A. Faroughy et al., EPiC-Ly Fast Particle Cloud Generation with Flow-Matching and Diffusion, arXiv preprint arXiv:2310.00049 (2023), 2310.00049.arxiv.org/abs/2310.00049
  60. [60]M. Leigh, D. Sengupta, G. Qué​tant et al., PC-JeDi: Diffusion for Particle Cloud Generation in High Energy Physics, SciPost Phys. 16, 018 (2024), doi:10.21468/SciPostPhys.16.1.018, 2303.05376.DOI
  61. [61]M. Leigh, D. Sengupta, J. A. Raine et al., Faster diffusion model with improved quality for particle cloud generation, Phys. Rev. D 109(1), 012010 (2024), doi:10.1103/PhysRevD.109.012010, 2307.06836.DOI
  62. [62]J. Birk, E. Buhmann, C. Ewen et al., Flow matching beyond kinematics: Generating jets with particle-id and trajectory displacement information, arXiv preprint arXiv:2312.00123 (2023).DOI
  63. [63]M. F. Giannelli, G. Kasieczka, C. Krause et al., Fast Calorimeter Simulation Challenge, https://calochallenge.github.io/homepage/ (2022).
  64. [64]M. Faucci Giannelli, G. Kasieczka, C. Krause et al., Fast Calorimeter Simulation Challenge 2022 - Dataset 2, doi:10.5281/zenodo.6366271 (2022).
  65. [65]M. Faucci Giannelli, G. Kasieczka, C. Krause et al., Fast Calorimeter Simulation Challenge 2022 - Dataset 3, doi:10.5281/zenodo.6366324 (2022).
  66. [66]G. Yang, X. Huang, Z. Hao et al., PointFlow: 3D Point Cloud Generation With Continuous Normalizing Flows, In 2019 IEEE/CVF International Conference on Computer Vision (ICCV). IEEE, doi:10.1109/iccv.2019.00464 (2019).DOI
  67. [67]D. P. Kingma and M. Welling, Auto-encoding variational bayes, arXiv preprint arXiv:1312.6114 (2013), 1312.6114.arxiv.org/abs/1312.6114
  68. [68]C. Durkan, A. Bekasov, I. Murray et al., Neural Spline Flows, In 33rd Conference on Neural Information Processing Systems (NeurIPS 2019) (2019), 1906.04032.arxiv.org/abs/1906.04032
  69. [69]B. Uria, I. Murray and H. Larochelle, Rnade: The real-valued neural autoregressive density-estimator, arXiv preprint arXiv:1306.0186 (2014), 1306.0186.arxiv.org/abs/1306.0186
  70. [70]J. Ho, X. Chen, A. Srinivas et al., Flow++: Improving flow-based generative models with variational dequantization and architecture design, arXiv preprint arXiv:1902.00275 (2019), 1902.00275.arxiv.org/abs/1902.00275
  71. [71]L. Dinh, J. Sohl-Dickstein and S. Bengio, Density estimation using real nvp, arXiv preprint arXiv:1605.08803 (2017), 1605.08803.arxiv.org/abs/1605.08803
  72. [72]D. Nielsen, P. Jaini, E. Hoogeboom et al., Survae flows: Surjections to bridge the gap between vaes and flows, arXiv preprint arXiv:2007.02731 (2020), 2007.02731.arxiv.org/abs/2007.02731
  73. [73]M. Zaheer, S. Kottur, S. Ravindraksh et al., Deep sets, arXiv preprint arXiv:1703.06114 (2018), 1703.06114.arxiv.org/abs/1703.06114
  74. [74]J. Liu, A. Kumar, J. Ba et al., Graph normalizing flows, arXiv preprint arXiv:1905.13177 (2019), 1905.13177.arxiv.org/abs/1905.13177

Paper details

vlnc:W_92jdwr5v
Version
v1 · latest
Published
Fresh — added to the Hub within the last 30 days
Added
License
CC BY 4.0
Usage

views · 0

downloads · 0

A view counts once per browser per day, a download each time the PDF is requested.

  • Physics and Astronomy

Not recorded for this paper

View statement
Looking for related papers…
Contents