Dream.exe: Fast Calorimeter Shower Emulator

• Dream.exe is a benchmarking framework for fast calorimeter simulation that integrates energy and shape networks to model detector responses.
• It employs conditional flow matching with transformer architectures and latent diffusion to efficiently address sparse, high-dimensional data.
• The framework achieves percent-level fidelity using autoregressive conditioning and bespoke ODE solvers for rapid LHC calorimeter simulations.

Searching arXiv for the cited CaloDREAM paper and closely related calorimeter-simulation context. CaloDREAM is a machine-learning framework for fast calorimeter detector-response emulation in high-energy physics, introduced in “CaloDREAM — Detector Response Emulation via Attentive Flow Matching” (Favaro et al., 2024). In this context, “Dream.exe” does not denote a generic executable program, but refers to a benchmarked modeling framework for generating calorimeter showers that would otherwise be simulated with computationally expensive Geant4 detector simulation. The framework targets fast simulation for LHC calorimeters, with a particular focus on realistic calorimeter showers conditioned on the incident particle energy. Its central technical contribution is the integration of Conditional Flow Matching with transformer-based architectures, together with latent diffusion and bespoke ODE solvers, to address sparse, high-dimensional calorimeter data at percent-level fidelity on CaloChallenge 2022 datasets 2 and 3 (Favaro et al., 2024).

1. Problem setting and benchmark scope

CaloDREAM addresses the problem of generating realistic calorimeter showers conditioned on the incident particle energy. The motivating application is fast simulation for LHC calorimeters, where Geant4-level simulation is accurate but computationally costly. The study is carried out on CaloChallenge 2022 datasets 2 and 3, each containing 200k Geant4 electron showers, split into 100k train/validation and 100k test, over a log-uniform incident energy range $inc \in [10^3,10^6]\ \text{MeV}$ (Favaro et al., 2024).

The detector has 90 physical layers, voxelized into 45 effective layers by combining absorber and active material. The dimensionality is severe. DS2 contains 6480 voxels total with $16\times 9$ angular/radial bins per layer, while DS3 contains 40500 voxels with $50\times 18$ bins per layer. The data are highly sparse, with a threshold at 15.15 keV, yet the modeling objective requires percent-level fidelity across both low-level voxel distributions and higher-level shower observables. This combination of high dimensionality, sparsity, broad dynamic range, and precision requirements is the core technical challenge (Favaro et al., 2024).

A central design choice is to factorize shower generation into an energy network for per-layer deposited energies and a shape network for the voxelized shower pattern conditioned on those energies: $$u_i \sim p_\phi(u_i \mid inc), \qquad x \sim p_\theta(x \mid inc,u).$$ Here $u$ encodes layer-energy information and $x$ denotes voxel values. This factorization is physically motivated and reduces the burden on the spatial generator. A plausible implication is that CaloDREAM treats longitudinal energy development and fine-grained spatial deposition as related but distinct statistical problems, rather than forcing a single generator to model the entire shower manifold at once.

2. Data representation and preprocessing

The preprocessing pipeline is integral to CaloDREAM’s performance. Rather than learning layer energies $E_i$ directly, the framework introduces invertible energy-ratio variables

$$u_0 = \frac{\sum_i E_i}{f\,inc}, \qquad u_i = \frac{E_i}{\sum_{j\ge i} E_j},\quad i=1,\dots,44,$$

with $f=2.85$, chosen so that $u_0\in[0,1]$. These variables enforce energy conservation and keep most targets in $16\times 9$0 (Favaro et al., 2024).

Voxel energies are normalized layer-wise. For full-space training, each normalized voxel $16\times 9$1 is transformed by a regularized logit: $16\times 9$2

$16\times 9$3

followed by standardization using the training-set mean and standard deviation. Postprocessing rescales generated voxels so each layer has the correct total normalization (Favaro et al., 2024).

This representation design is not merely numerical convenience. The energy-ratio variables embed longitudinal constraints directly into the target parameterization, while the voxel transform regularizes extreme sparsity and bounded support. This suggests that much of CaloDREAM’s accuracy derives from encoding physically meaningful inductive structure before the generative model is trained, rather than relying on the backbone alone.

3. Conditional Flow Matching backbone

The generative backbone throughout CaloDREAM is Conditional Flow Matching. It defines a continuous transport from Gaussian noise to data through an ODE

$16\times 9$4

with associated continuity equation

$16\times 9$5

The boundary conditions are

$16\times 9$6

The learned velocity field $16\times 9$7 is trained using a linear interpolation path between noise $16\times 9$8 and data $16\times 9$9: $50\times 18$0 Conditioning is implemented by allowing $50\times 18$1 to depend on extra inputs such as $50\times 18$2, $50\times 18$3, or transformer embeddings (Favaro et al., 2024).

Within CaloDREAM, CFM is the common transport mechanism for both low-dimensional structured variables and high-dimensional calorimeter geometry. The significance of this unification is methodological: the same transport formalism can be specialized to autoregressive per-layer energy generation and patchwise spatial velocity prediction, permitting architectural heterogeneity without changing the underlying generative principle.

4. Energy network and spatial generator

For the energy network, CaloDREAM uses an autoregressive Transfusion-style transformer plus CFM. The transformer encoder embeds the incident energy; the decoder receives the sequence of previously generated $50\times 18$4-variables with masked self-attention, plus cross-attention to the energy embedding. It outputs context vectors

$50\times 18$5

A single dense conditional flow network $50\times 18$6 is then reused per layer: $50\times 18$7 corresponding to the autoregressive factorization

$50\times 18$8

Training parallelizes loss contributions over all $50\times 18$9, but sampling is sequential layer-by-layer (Favaro et al., 2024).

The architecture details are explicit. The transformer uses embedding dimension 64, 4 layers, 4 heads, and intermediate dimension 1024; the CFM dense network has 8 layers, hidden size 256, and SiLU activations. Training uses 500 epochs, batch size 4096, cosine LR schedule, max LR $$u_i \sim p_\phi(u_i \mid inc), \qquad x \sim p_\theta(x \mid inc,u).$$0, and RK4 with 50 steps (Favaro et al., 2024).

For the shape network, CaloDREAM uses a 3D Vision Transformer to learn the velocity field

$$u_i \sim p_\phi(u_i \mid inc), \qquad x \sim p_\theta(x \mid inc,u).$$1

The calorimeter volume is split into non-overlapping patches, each linearly embedded, augmented by learned positional encodings, and processed by transformer blocks. Conditioning enters via a joint embedding of $$u_i \sim p_\phi(u_i \mid inc), \qquad x \sim p_\theta(x \mid inc,u).$$2, $$u_i \sim p_\phi(u_i \mid inc), \qquad x \sim p_\theta(x \mid inc,u).$$3, and $$u_i \sim p_\phi(u_i \mid inc), \qquad x \sim p_\theta(x \mid inc,u).$$4. Time and energy are embedded by separate dense nets and summed; the condition modulates each transformer block through affine scale/shift plus residual rescaling: $$u_i \sim p_\phi(u_i \mid inc), \qquad x \sim p_\theta(x \mid inc,u).$$5

$$u_i \sim p_\phi(u_i \mid inc), \qquad x \sim p_\theta(x \mid inc,u).$$6

where $$u_i \sim p_\phi(u_i \mid inc), \qquad x \sim p_\theta(x \mid inc,u).$$7 is multi-head self-attention and $$u_i \sim p_\phi(u_i \mid inc), \qquad x \sim p_\theta(x \mid inc,u).$$8 is the MLP transformation (Favaro et al., 2024).

The exact ViT hyperparameters depend on dataset and representation regime.

Model	Dataset	Key hyperparameters
Full-space ViT	DS2	patch size $$u_i \sim p_\phi(u_i \mid inc), \qquad x \sim p_\theta(x \mid inc,u).$$9, embedding dim 480, 6 heads, MLP dim 1920, 6 blocks, 800 epochs, batch size 64
Full-space ViT	DS3	patch size $u$0, embedding dim 240, 6 heads, MLP dim 720, 6 blocks, 600 epochs, batch size 64
laViT	DS2	patch size $u$1, 10 blocks, embedding dim 240, 6 heads, MLP dim 960, batch size 128
laViT	DS3	patch size $u$2, 10 blocks, embedding dim 240, 6 heads, MLP dim 960, batch size 128

Shape-network training uses cosine schedule, max LR $u$3, and RK4 with 20 steps (Favaro et al., 2024).

The main architectural conclusion stated in the paper is that the autoregressive transformer factorization is crucial for modeling the sharp zero/one peaks in late-layer energy ratios, while the ViT patch-based architecture scales better than older flow architectures to high-dimensional voxel space. This places CaloDREAM within a broader class of structured generative models in which causality across detector depth and spatial locality within layers are handled by different inductive biases.

5. Latent modeling and solver acceleration

A major contribution of CaloDREAM is the use of latent diffusion, or more precisely latent flow matching, for the high-dimensional spatial component. Instead of learning directly in voxel space, the framework trains a variational autoencoder with parameters $u$4. The encoder outputs $u$5, defining

$u$6

The latent posterior is written $u$7, and the decoder $u$8. The training loss is

$u$9

with $x$0. In appendix form the reconstruction is also written as

$x$1

Because voxels are normalized to $x$2, a Bernoulli decoder is viable (Favaro et al., 2024).

The latent CFM transports Gaussian noise to the learned latent manifold: $x$3 Sampling becomes

$x$4

The latent reduction factor is $x$5, with a bottleneck of two channels. The VAE is convolutional, with 2 blocks plus bottleneck and channels $x$6. Bottleneck dimensions are $x$7 for DS2 and $x$8 for DS3. Training uses 200 epochs, batch size 1000, OneCycle schedule, max LR $x$9, sigmoid output, and normalized cut $E_i$0. Spatial coordinates are added as input channels to break pure translation equivariance (Favaro et al., 2024).

The efficiency gain from latent modeling is complemented by bespoke non-stationary ODE solvers. Standard diffusion or flow sampling can require $E_i$1 ODE steps. The bespoke solver parameterizes each step as

$E_i$2

with

$E_i$3

$E_i$4

An $E_i$5-step solver has $E_i$6 learnable parameters. Two objectives are studied: $E_i$7 and

$E_i$8

These solvers are trained with the vector field frozen, initialized from Euler, using Adam at $E_i$9, batch size 100, up to 5000 iterations, with a midpoint 100-step reference solver (Favaro et al., 2024).

This solver study is significant because it is explicitly a training-light, task-adapted solver optimization rather than full model distillation. In practical terms, it separates generative-model training from numerical-sampling optimization, which is attractive in detector simulation settings where retraining large generators is costly.

6. Empirical performance, efficiency, and limitations

The energy network performs strongly. Selected $$u_0 = \frac{\sum_i E_i}{f\,inc}, \qquad u_i = \frac{E_i}{\sum_{j\ge i} E_j},\quad i=1,\dots,44,$$0 distributions match Geant4 closely, and a classifier trained to separate generated $$u_0 = \frac{\sum_i E_i}{f\,inc}, \qquad u_i = \frac{E_i}{\sum_{j\ge i} E_j},\quad i=1,\dots,44,$$1-vectors from truth yields AUC around 0.51, which is essentially random discrimination. The hardest variables are the late-layer $$u_0 = \frac{\sum_i E_i}{f\,inc}, \qquad u_i = \frac{E_i}{\sum_{j\ge i} E_j},\quad i=1,\dots,44,$$2, which have sharp peaks at 0 or 1 corresponding to shower termination patterns; the autoregressive design is reported to help capture these features (Favaro et al., 2024).

For full shower generation on DS2, both the full-space ViT and latent laViT reproduce layerwise energy and shape observables well. The observables examined include center of energy and width in $$u_0 = \frac{\sum_i E_i}{f\,inc}, \qquad u_i = \frac{E_i}{\sum_{j\ge i} E_j},\quad i=1,\dots,44,$$3,

$$u_0 = \frac{\sum_i E_i}{f\,inc}, \qquad u_i = \frac{E_i}{\sum_{j\ge i} E_j},\quad i=1,\dots,44,$$4

and a radial shower-depth observable

$$u_0 = \frac{\sum_i E_i}{f\,inc}, \qquad u_i = \frac{E_i}{\sum_{j\ge i} E_j},\quad i=1,\dots,44,$$5

Both models are accurate at the few-percent level in most regions. The main discrepancy is in very low-energy voxels: the latent model overpopulates tiny energy deposits and therefore distorts the sparsity distribution. Applying an extra cut $$u_0 = \frac{\sum_i E_i}{f\,inc}, \qquad u_i = \frac{E_i}{\sum_{j\ge i} E_j},\quad i=1,\dots,44,$$6 MeV largely fixes the mismatch while leaving total deposited energy almost unchanged (Favaro et al., 2024).

For DS3, the paper’s central scaling question is whether the same methodology remains effective at 40500 dimensions. The reported answer is mostly yes, although the full-space ViT becomes computationally heavy. The latent model is therefore especially important. Results are qualitatively similar to DS2, with good modeling of high-level observables and only mild degradation in data-sparse regions. Again, the principal issue is the low-energy voxel tail and sparsity. After applying the same $$u_0 = \frac{\sum_i E_i}{f\,inc}, \qquad u_i = \frac{E_i}{\sum_{j\ge i} E_j},\quad i=1,\dots,44,$$7 MeV threshold, the latent DS3 model’s agreement becomes excellent (Favaro et al., 2024).

AUC-based summary metrics are reported as follows:

Model	Low-level AUC	High-level AUC
DS2 ViT	$$u_0 = \frac{\sum_i E_i}{f\,inc}, \qquad u_i = \frac{E_i}{\sum_{j\ge i} E_j},\quad i=1,\dots,44,$$8	$$u_0 = \frac{\sum_i E_i}{f\,inc}, \qquad u_i = \frac{E_i}{\sum_{j\ge i} E_j},\quad i=1,\dots,44,$$9
DS2 laViT	$f=2.85$0	$f=2.85$1
DS3 ViT	$f=2.85$2	$f=2.85$3
DS3 laViT	$f=2.85$4	$f=2.85$5

Lower is better, with 0.5 meaning indistinguishable. The authors interpret the DS2 ViT and DS3 high-level ViT as state-of-the-art quality. They also study learned classifier-weight distributions using

$f=2.85$6

finding that weights are centered near $f=2.85$7, while latent models show broader distributions and less smooth tails, consistent with reduced-fidelity latent reconstruction. The classifier additionally suggests residual cross-layer failure modes correlated with shower depth (Favaro et al., 2024).

Sampling-efficiency results show that Euler is inefficient and that quality of non-Euler methods essentially saturates by $f=2.85$8. The bespoke solvers dominate at low budgets. The local BNS keeps AUC below 0.6 for both high- and low-level classifiers even at 8 function evaluations and reaches saturation by 32 evaluations. The global BNS is particularly good for high-level features at 4 evaluations (Favaro et al., 2024).

Wall-clock timing on an NVIDIA H100 for one forward pass at batch size 100 is also reported:

Component	DS2	DS3
Energy network	about 0.37 ms	about 0.37 ms
Shape ViT	$f=2.85$9 ms	$u_0\in[0,1]$0 ms
laViT	$u_0\in[0,1]$1 ms	$u_0\in[0,1]$2 ms

The latent model is slower than full-space on DS2 but faster on DS3, reflecting the dimensionality tradeoff. Because the energy model is autoregressive, an $u_0\in[0,1]$3-step solver for 45 layers costs $u_0\in[0,1]$4 function evaluations there (Favaro et al., 2024).

The limitations are explicit. First, latent-space reconstruction weakens fidelity for low-energy sparse voxels and impacts sparsity distributions. Second, the DS3 full-space model is near the computation limit described by the authors. Third, all studies are conducted on a simplified benchmark geometry with electrons entering at a fixed point and angle. Further work is identified for irregular real detector geometries, other particle species such as hadrons, and varying angles of incidence. Bayesian uncertainty-aware versions are also described as desirable but too expensive in the present study. More broadly, the latent reduction factor was fixed rather than optimized, leaving room for improved compression-fidelity tradeoffs (Favaro et al., 2024).

A common misconception is that CaloDREAM is a desktop-style executable because of the name “Dream.” The paper explicitly presents it instead as a research framework for fast detector simulation: simultaneously a model family, a public codebase, and a benchmark study on CaloChallenge datasets. The cited implementation is heidelberg-hepml/calo_dreamer, and dependencies are described at the level of transformer architectures, conditional flow matching, variational autoencoders, and ODE solvers rather than as a packaged deployment service (Favaro et al., 2024).