Physics-Factored Patch Translation for Large Liquid-Argon Detectors

Detectors that search for rare events keep getting bigger because sensitivity grows with target mass. In a liquid-argon time projection chamber (a tank of liquid argon in which charged particles leave trails of ionization electrons that an electric field drifts, over meters, onto a readout plane), larger size means longer drift. Longer drift means more of the signal is lost to impurities, more of it is blurred by diffusion, and more of it is displaced by distortions of the electric field. Deep-learning reconstruction for these detectors is trained on simulated images, and simulation never matches the real detector exactly. The most promising fix so far is to train a generative adversarial network (GAN: a generator trained against a critic that tries to tell its outputs from real data) to translate simulated readouts into realistic ones without paired examples. These translators are expensive, though, and they only run on 256×256 patches. Full readout frames span thousands to tens of thousands of channels, and the effects that grow with detector size are exactly the ones that vary across the whole frame.

We propose to split the translator into two parts. The first is a small, explicit, differentiable drift operator with a handful of physical parameters: electron lifetime, diffusion coefficients, and a low-order field-distortion map. It acts on the whole frame at negligible cost. The second is a local adversarial residual network that is trained on patches and is deliberately blind to position. Because every drift-dependent effect is forced through the operator, patch-level training remains enough as the detector grows. Training cost stops depending on frame size. As a by-product, the fitted operator parameters are a calibration of the detector, inferred from unpaired data, without the 25-fold slowdown of a fully differentiable simulator.

Core Claim

The long-range structure that makes full-frame translation seem necessary in large liquid-argon detectors is low-dimensional and follows known physics. This is why the split works. Along the time axis of each readout wire, the electronics and field response is a linear convolution, and diffusion is a Gaussian convolution, so the two commute locally. Lifetime attenuation is a slowly varying multiplicative factor, so it approximately commutes with both. It is therefore legitimate to apply drift physics directly to a simulated readout image rather than re-simulating charge transport. Concretely, the translated image is

$$\hat{x}_B = R_\psi\big(D_\theta(x_A;\, t, w)\big),$$

where $x_A$ is a simulated readout frame and $t, w$ are each pixel's drift time and wire coordinate. $D_\theta$ applies attenuation $e^{-t/\tau}$, time-dependent Gaussian smearing of width $\sqrt{2 D_L t}$ along time and $\sqrt{2 D_T t}$ across wires, and a displacement warp from a low-order basis for space-charge distortion. The parameters are $\theta = (\tau, D_L, D_T, \text{warp coefficients})$. $R_\psi$ is a patch-level residual network that receives no coordinate input.

Only the critic sees patches. It is conditioned on patch drift position, so its errors inform the global $\theta$. What gets fitted to unpaired realistic data is therefore frame-level physics, even though every gradient step touches only local windows. The residual absorbs whatever does not commute, such as fine field-response detail. Because it has no coordinate input, it cannot learn drift-dependent effects, and so it cannot compete with $D_\theta$ to explain them. That constraint is what makes $\theta$ identifiable and gives it physical meaning.

Relation to Prior Work

Three papers define the gap. Unpaired image translation to mitigate domain shift in LArTPC detector responses compared CycleGAN, ACL-GAN, U-GAT-IT and UVCGAN on the SLATS dataset, which pairs a simplified 1D field response against a realistic 2D one. It found that UVCGAN cut electron-count error by up to 80%. That paper motivates this proposal: it shows translation works. It also constrains it. It was restricted to 256×256 tiles by the cost of dual generators and critics, and it contains no drift-dependent effects at all. We keep its evaluation protocol and add exactly the physics it omits.

Differentiable simulation of a liquid argon time projection chamber rewrote larnd-sim in PyTorch and fit entangled parameters jointly to within 1% in closure tests. It reports that the forward pass is about 25 times slower than the original code, that backpropagation needs checkpointing to fit in memory, and that deployment on real data requires particle trajectory segments that themselves depend on the calibration. We reuse its core lesson, that joint fitting breaks the degeneracies sequential calibration leaves behind, but we fit at the image level from unpaired data rather than through the full charge-transport simulation.

IEA-GAN showed that patch-independent generators destroy correlations across sensors in the Belle II pixel detector. It repaired this with a graph transformer over 40 sensors, at substantial training cost. Our answer to the same failure differs: we remove long-range structure from what the network must learn, rather than adding capacity to learn it. CaloChallenge 2022 supplies the broader context. Diffusion and flow-matching models reach the best fidelity at high granularity, while GANs are the fastest at inference. We treat the choice of residual model as secondary to the factoring, and we test it.

On the detector side, operating experience from ProtoDUNE-SP establishes the parameters that matter and their ranges. Spatial and temporal evaluations of the liquid argon purity in ProtoDUNE-SP reports lifetimes often above 30 ms, against a 10 ms far-detector specification, that vary in space and time. Modeling impurity concentrations in liquid argon detectors addresses why they vary. Scintillation light detection in the 6-m drift-length ProtoDUNE Dual Phase TPC sets the drift scale that multi-kiloton modules approach.

Research Program

The first step is to build the benchmark, because none in the file contains drift effects together with unpaired evaluation. We will extend SLATS into what we call SLATS-Drift using the fast, non-differentiable larnd-sim. Domain A keeps the simplified response with no attenuation, diffusion or distortion. Domain B uses the realistic response plus lifetime, diffusion and a space-charge displacement field, each drawn from ProtoDUNE-like ranges. We will generate variants with maximum drift lengths stepped up toward 6 m, so that detector scale becomes a controlled variable. Paired ground truth is retained for the test split only.

The second step is to implement the operator $D_\theta$ as a GPU kernel. It needs a depth-dependent Gaussian blur, a multiplicative map and a smooth warp, all of which are cheap compared with a convolutional backbone. We will train it jointly with the residual network under an unpaired adversarial loss on coordinate-tagged patches, plus a small penalty on residual magnitude.

We will state three identifiability limits up front. First, the absolute charge scale is degenerate with gain and recombination under unpaired training. We therefore fit only drift-dependent quantities and anchor the overall scale with a single normalization term. Second, the mapping must be kept invertible in the B→A direction used by the prior paper. Third, the warp basis must be low enough in order that the residual cannot fake it locally.

The third step is analysis. We will measure how training memory and GPU-hours scale with frame size for the factored model and for a full-frame UVCGAN. We will also measure how the recovered $\theta$ depends on the amount of unpaired data.

Baselines

The naive reference point is to translate nothing: train downstream models on Domain A and test them on Domain B. This measures the size of the domain shift we are trying to close.

The strongest existing method is UVCGAN as configured in the SLATS paper, which reports up to 80% reduction in electron-count error for B→A. On SLATS-Drift we will run it on 256×256 tiles, with the same number of training images and the same GPU-hour budget as our model. It will get an equal hyperparameter search of fixed size, and it may add the drift-coordinate channels described next. We will also attempt a full-frame UVCGAN at the largest frame size that fits the memory we use, and report where it fails. To beat UVCGAN, the factored model must match or reduce its electron-count error and pixel error on SLATS-Drift, with the gap widening as drift length grows. It must also do so at no more training compute and flat memory in frame size.

The calibration baseline is the differentiable larnd-sim, fit on the same closure events with its dynamic-time-warping loss. That paper reports convergence to within 1% of the true parameters after 5000 mini-batch iterations, but it assumes known particle trajectories. We will compare parameter error against wall-clock time. The bar to clear is recovering $\tau$ and $D_L, D_T$ within a few percent while using only unpaired images and a fraction of the compute. Matching 1% is not required, given that we do not assume known trajectories.

Two ablations isolate the key ingredient. The first gives the residual network coordinate input and removes the operator, so position dependence is learned rather than modeled. The second keeps the operator but lets the residual see coordinates, which tests whether blinding the residual is what makes $\theta$ identifiable.

Why not just…?

Why not just give the patch GAN its drift coordinate and let it learn position dependence? This is the most serious threat, and it is exactly the first ablation. With enough data it may match in-distribution fidelity. We expect it to fail in two places the factored model should not. It cannot extrapolate to drift lengths longer than those seen in training, and SLATS-Drift holds out the largest drift variant for this purpose. It also yields no calibration parameters. If it matches the factored model on held-out drift lengths as well, the physics operator is only a calibration tool, and we will report it that way.

Why not just calibrate with the differentiable simulator and then generate with it? It gives exact physics and has demonstrated 1% closure. However, the reported 25-fold forward slowdown and checkpointed backpropagation make it costly as a data generator. It also needs trajectory segments inferred from the very hits whose calibration is unknown. The wall-clock comparison of parameter error decides whether our image-level fit is cheaper for acceptable accuracy. If the differentiable simulator is both cheaper and more accurate, the proposal's calibration claim fails, while the translation claim can still stand.

Why not just calibrate classically first, correct the simulation analytically, and then train a patch GAN on what remains? This two-stage pipeline is close to ours. Its first stage is proven: cathode-crossing and CRT-matched lifetime measurements in ProtoDUNE-SP agree with χ²/ndf around 1. The differentiable-simulation paper, however, reports that sequential fitting of entangled parameters leaves biases. We will run the two-stage version by fixing $\theta$ to separately fitted values before training the residual. If it performs as well as the joint fit, the extra benefit of joint training is nil, and we will say so.

Why not just use a diffusion or flow-matching translator, which CaloChallenge found more faithful? Nothing in the factoring depends on the residual being adversarial. We will swap in a conditional flow-matching residual under the same budget. Because the residual is small and local, we expect the fidelity gap to shrink and the GAN's inference-speed advantage to remain. If it does not shrink, the recommendation becomes a factored diffusion model.

Proposed Experiments

The decisive experiment is fidelity as a function of drift length on SLATS-Drift. The metrics are the SLATS paper's signal-processing electron-count error, its pixel error against paired truth, and its supervised regression of true deposited charge trained on translated data. The prediction is that tile-based UVCGAN degrades as drift grows, because each tile sees only a slice of the attenuation and blur gradient, while the factored model stays flat. The largest drift variant is held out entirely from training.

The second check is parameter recovery. For each of 20 randomly drawn Domain B configurations, we will report the error of the recovered $\tau$, $D_L$, $D_T$ and warp amplitude, together with GPU-hours, against the differentiable-simulator fit.

The third check is scaling cost: peak memory and time per training step against frame width, from a 256-pixel tile up to full frames, for the factored model and for full-frame UVCGAN.

The fourth check is a downstream task. We will train a patch classifier for track-like versus shower-like hits on 48×48 windows, following Separation of track- and shower-like energy deposits in ProtoDUNE-SP using a CNN, which reports a hit-level shower F1 of 0.72 on its own simulated data. It will be trained on translated data and tested on Domain B, with the aim of closing the gap to a classifier trained on Domain B directly.

If real ProtoDUNE-SP frames are accessible, a final check is to fit $\tau$ from unpaired real data and compare it with the published cathode-crossing lifetimes. We report no drift-dependent translation result from prior work, because no reported result was found on Lacuna for translation under drift effects.