Introduction (Theoretical Background)

Digital pulse shaping has become a cornerstone technique in modern nuclear spectroscopy, offering high flexibility and performance compared to its analog counterparts. In particular, Jordanov and Knoll (see “Digital Synthesis of Pulse Shapes in Real Time for High Resolution Radiation Spectroscopy”, NIM A 345, 1994) describe a versatile recursive method to generate trapezoidal or triangular pulse shapes digitally, replacing traditional analog shaping amplifiers. Their approach provides real-time pulse processing with several notable advantages:

1. Noise Reduction & Shaping
   By convolving an exponential (or step-like) preamplifier output with discrete filter kernels (rectangular, ramp, or cusp-like), one obtains shaped pulses optimized for high resolution. Trapezoidal and triangular filters, in particular, help to reduce both low-frequency (baseline) and high-frequency (electronic) noise, improving the signal-to-noise ratio for each detected event.

2. Ballistic Deficit Control
   When measuring pulses from detectors (e.g., HPGe), variations in charge collection time can cause ballistic deficit, resulting in amplitude underestimation if the shaping time is too short. The trapezoidal filter’s adjustable flat top partially decouples the arrival time of the pulse from its measurement time, mitigating ballistic deficit and preserving energy resolution across a range of rise times.

3. Recursive Digital Algorithms
   At the heart of their technique is a set of simple recursive equations that efficiently approximate the same convolution steps an analog CR–RC shaper would perform. By cleverly combining a moving average (rectangular) filter and a truncated ramp convolution, the authors produce symmetric trapezoids: \[ s(n) ;=; \text{(recursive sum of delayed samples)} ;-; \text{(previous partial sums)}, \] with parameters defining rise time, flat-top duration, and decay. These computations require only standard adders, subtractors, multipliers, and delays in an FPGA or DSP, making them feasible for high count-rate applications.

4. Real-Time Flexibility
   A purely digital implementation allows shaping parameters—like peaking time, flat-top length, and decay constant compensation—to be reconfigured quickly in firmware or software. Unlike fixed analog circuits, one can switch from a triangular response (for delta-noise–limited conditions) to a flat-top trapezoid (for ballistic-deficit–limited conditions) without changing hardware.

5. Improved Energy Resolution
   Jordanov and Knoll’s preliminary tests showed that digital trapezoidal shaping can outperform standard quasi-Gaussian analog shapers, especially at shorter shaping times. This is critical in high-count-rate scenarios, where pile-up is a major concern and minimal pulse width is desired without sacrificing resolution.

Overall, digital trapezoidal filtering represents a powerful alternative to traditional analog methods, affording not only lower noise and ballistic deficit management but also real-time adaptability to varying detector signals. In this lab, we draw upon the theory and methods described by Jordanov and Knoll to simulate and implement a Recursive Trapezoidal Filter, demonstrating how to optimize pulse shape parameters for accurate high-resolution spectroscopy.

Recursive Digital Algorithms (Explaination)

A core insight from Jordanov and Knoll is that trapezoidal shaping can be achieved digitally by recursive convolution with simple kernel functions. Rather than performing a direct (non‐recursive) convolution, which can be computationally expensive for each sample, they demonstrate difference equations that reuse previous intermediate results. These recursive algorithms require only a small number of adders/subtractors, delay elements, and registers, making them ideal for real‐time FPGA or DSP implementations at high count rates.

Below is a conceptual block diagram of the trapezoidal filter from Jordanov and Knoll, showing how the sampled input \(v(n)\) passes through delays and accumulations to produce the shaped output \(s(n)\). Each dashed box indicates a major stage:

1. First Delay & Subtraction (green box, left)

   • DELAY_1 \([k]\): Holds each sample \(v(n)\) for \(k\) clock cycles, effectively outputting \(v(n - k)\).
   • RS1 (subtracter): Computes
     \[ d^{k}(n) = v(n) - v(n - k). \]
   • Meaning: This difference \(\bigl[v(n) - v(n - k)\bigr]\) implements a discrete “moving window” of width \(k\). It is effectively the “boxcar” or rectangular filter difference used in building a trapezoidal shape.

2. Second Delay & Subtraction (green box, middle)

   • DELAY_2 \([l]\): Holds each sample of \(d^{k}(n)\) for \(l\) clock cycles, giving \(d^{k}(n - l)\).
   • RS2 (subtracter): Computes
     \[ d^{k,l}(n) = d^{k}(n)- d^{k}(n - l). \]
   • Meaning: This second difference step can provide the flat‐top portion or other shaping elements. By adjusting \(k\) and \(l\), we set the trapezoid’s rise time, flat‐top duration, or other shaping intervals.

At this point, \(d^{k,l}(n)\) is an intermediate “slope control” signal—effectively the difference of two moving averages (or differences) delayed by \(l\).

3. Accumulator Stage (green box, right)

   • Multiplier \(M\): Often used for exponential decay correction or a simple gain factor. In many designs, if the input is an exponentially decaying pulse (from a preamp), \(M\) can be set to account for the time constant, or it can be unity if no correction is needed.
   • ACC (labeled “ACC” in the figure): This accumulator adds the current sample \(d^{k,l}(n)\times M\) (or a scaled difference) to its previous sum. Formally,
     \[ r(n) = r(n - 1)+ M \cdot d^{k,l}(n). \]
   • DEC (possibly a second accumulator or “decimation”): Another small summation or offset step that can feed into the final output \(s(n)\). Sometimes referred to as a final add/sub step to combine partial sums.

4. Final Output \(s(n)\)

   • The last accumulator or adder produces the fully shaped output
     \[ s(n) = \text{(some partial sum of }r(n)\text{)}. \]
   • In many designs, \(s(n)\) is simply \(r(n)\) or \(r(n) + \) (some offset), depending on the chosen difference equation.

Putting It All Together

1. Input
   \(\quad v(n)\) is your digitized preamp signal or pulse.

2. First Box (Delay \([k]\) + subtract)
   \(\quad d^{k}(n) = v(n) - v(n-k)\)
   \(\quad\) This step is like a “first derivative” over \(k\) samples.

3. Second Box (Delay \([l]\) + subtract)
   \(\quad d^{k,l}(n) = d^{k}(n) - d^{k}(n-l)\)
   \(\quad\) By subtracting delayed versions of \(d^{k}(n)\), we begin forming a trapezoidal or flattop shape.

4. Accumulator & Multiplier
   \(\quad r(n) = r(n-1) + M\cdot d^{k,l}(n)\)
   \(\quad\) Summing this difference over time yields the final shaped “pulse.” \(M\) can be used to correct exponential tails or set digital gain.

5. Final Sum leads to \(s(n)\), the shaped output.
   \(\quad\) Sometimes an additional offset or partial sum is combined in a final adder (shown as “ACC” and “DEC” in the diagram), but the principle is the same: accumulate the difference signals to build a symmetrical trapezoid or triangular pulse.

The net result is a recursive trapezoidal filter: each new output sample \(s(n)\) depends on a small combination of current and delayed inputs plus the previous filter states. This approach is computationally efficient—requiring only a few adders, subtractors, and multipliers—and is thus ideal for real‐time digital pulse shaping in nuclear spectroscopy or any system needing adjustable trapezoidal shaping.

Computing the Deconvolution Constant \(M\)

When performing tail cancellation or exponential deconvolution in Jordanov‐style trapezoidal filtering, one often introduces a factor \(M\) that corrects for the exponential decay in the preamplifier output. The typical formula (as shown in many digital spectroscopy references) is:

\[ M ;\approx; \frac{K}{\exp\Bigl(\frac{T_{\text{s}}}{\tau}\Bigr);-;1}, \]

where:

• \(\tau\) is the decay time constant of the signal (e.g.\ from a charge‐sensitive preamp),
• \(T_{\text{s}} = 1 / f_{\text{clock}}\) is the sampling period,
• \(K\) is a scaling factor (for instance \(K = 256\) or \(K=2^{N}\)) depending on the fixed‐point implementation or desired gain range.

Example with \(f_{\text{clock}} = 65,\text{MHz}\) and \(\tau=2,\mu\text{s}\)

1. Calculate Sampling Period
   \[ T_{\text{s}} = \frac{1}{f_{\text{clock}}} = \frac{1}{65\times 10^{6},\text{Hz}} \approx 15.3846,\text{ns}. \]

2. Compute Ratio \(\tfrac{T_{\text{s}}}{\tau}\)
   Here \(\tau=2,\mu\text{s}\). So
   \[ \frac{T_{\text{s}}}{\tau}= \frac{15.3846\times 10^{-9}}{2\times 10^{-6}}= 7.6923\times 10^{-3}. \]

3. Exponentiate
   \[ \exp\Bigl(\frac{T_{\text{s}}}{\tau}\Bigr) = \exp\bigl(0.0076923\bigr) \approx 1.00772. \] Then
   \[ \exp\Bigl(\frac{T_{\text{s}}}{\tau}\Bigr)-1= 1.00772-1= 0.00772. \]

4. Divide into \(K\)
   Let us assume \(K = 256\) (a common choice for a \(Q15.8\) or \(U8.8\) fixed‐point format). Then
   \[ M= \frac{256}{0.00772} \approx 33{,}160. \] (In practice, you might round to an integer, e.g.\ 33,160 or 33,000 depending on your filter’s numerical precision and available bitwidth.)

Hence, \(M \approx 33{,}160\) for a 65 MHz sampling clock and a 2 µs decay constant, if using a scaling factor \(K=256\). In an actual firmware or FPGA register, one would store this approximate integer value. During filtering, the tail‐correction multiply uses \(M\) to counteract the exponential decay.

Why This Works

• Basic Idea: Each sample step \(\Delta t = T_{\text{s}}\), the signal decays by a factor of \(\exp(-\Delta t/\tau)\approx 1 - \tfrac{\Delta t}{\tau}\).
• Digital Correction: By adding back a small fraction \(M\cdot[d(n)]\) of the difference term, we effectively remove the slow tail.
• Tunability: If \(\tau\) changes, or the sampling frequency changes, recompute \(M\) accordingly.

This method is often referred to as pole‐zero cancellation in the digital domain, letting you precisely match the preamplifier’s decay without the drift and tolerance issues of analog RC networks.

1. Block‐by‐Block Configuration

This section describes how the recursive trapezoidal filter is built and simulated within Sci‐Compiler. We will walk through each block’s configuration, explain how pipelining is managed, and show how to supply an exponential signal from the Detector Emulator as the input stimulus. Finally, we’ll examine the resulting waveforms in GTKWave.

Below is a reference to each major component in the diagram, with the block name (e.g., Subtractor U3) and its main parameters:

1. Delay (U1)

   • Function: Delays the 16‐bit input by a specified number of samples (here, 100).
   • Property Editor: Input bits = 16, Signed = YES, Output size = “SAME INPUT”, Overflow protection enabled.
   • Purpose: This block provides the \(v(n - k)\) signal in the difference equation. It feeds the next subtractor (U3).

2. Subtractor (U3)

   • Inputs:
     • IN1 from the original A0 (16 bits)
     • IN2 from the delayed output of U1 (also 16 bits)
   • Property Editor: Both inputs are 16 bits, signed.
   • Purpose: Produces \(d^k(n) = v(n) - v(n - k)\). This is the first difference in the trapezoid filter recursion.

3. Delay (U2)

   • Function: Another 16‐bit delay, typically 120 samples.
   • Purpose: This block shifts \(d^k(n)\) by \(l\) samples to implement the second difference if needed. Feeds the second subtractor (U4).

4. Subtractor (U4)

   • Inputs:
     • IN1 from the direct path of \(d^k(n)\)
     • IN2 from the delayed version \(d^k(n - l)\)
   • Purpose: Outputs \(d^{k,l}(n) = d^k(n) - d^k(n - l)\). This can shape the “flat top” region or other trapezoid parameters.

5. DSP‐MULT (U6)

   • Inputs:
     • 16‐bit from Subtractor U4 (signed)
     • A constant or register containing the factor \(M\) (e.g. for deconvolution).
   • Property Editor:
     • Input bits 1 = 16, Input bits 2 = 16, both Signed.
     • Latency = 4 (pipeline stages).
   • Purpose: Implements \( M \cdot d^{k,l}(n) \) if you are doing exponential tail cancellation or simply applying digital gain. Because it is pipelined with Latency=4, you must match that in the subsequent accumulators.

6. DSP‐ACCUMULATOR (U5)

   • Property Editor: 16 bits in, 32 bits for the accumulator, Signed, Latency=4.
   • Purpose: Accumulates the multiplier output over time:
     \[ p(n) = p(n-1) + M \cdot d^{k,l}(n). \]
   • The pipeline latency means it takes 4 clock cycles from the input to produce a stable output, so all subsequent signals must be aligned accordingly.

7. ADD (U7)

   • Inputs:
     • 32‐bit from the accumulator U5
     • 32‐bit from something else (e.g., the direct difference or a partial sum)
   • Property Editor: Input bits=32, Signed=YES, “SAME INPUT” for output.
   • Purpose: Combines partial sums or offsets (for instance, adding one more difference term). This stage is also pipelined.

8. DSP‐ACCUMULATOR (U8)

   • Inputs: 32‐bit from the ADD stage.
   • Property Editor: Input bits=32, Accumulator size=64, Signed=YES, Latency=4.
   • Purpose: Final accumulation to produce \(s(n)\). The output can be up to 64 bits to prevent overflow from repeated additions.

Pipeline Considerations

All DSP blocks (the Multiplier, Subtractors, Accumulators, etc.) have pipeline registers. For instance, U6 (the multiplier) and the Accumulators (U5, U8) each have a latency of 4 cycles.

• Why? So they can meet timing at high clock frequencies without losing data.
• Consequence: Downstream logic must wait the same number of clock cycles for valid data. This is why the delays and accumulations are carefully matched to keep the filter signals in sync.

2. Signal Probes

The diagram shows several “SIM” outputs or signals to examine in simulation:

• P_dk: The first difference \(d^k(n) = v(n) - v(n - k)\).
• P_dkl: The second difference \(d^{k,l}(n)\).
• P_p: Partial sum from the first accumulator (U5).
• P_r: Potentially another partial sum or intermediate result.
• P_s: The final shaped output from the last accumulator (U8).

We can observe each of these in the simulation waveforms to confirm the trapezoid shape is being generated.

3. Setting the Input Stimulus (Detector Emulator)

1. Right‐Click on the ANALOG IN PIN (A0).

2. Choose “Add / Edit Simulation Stimulus…”.

3. From the Mode dropdown, select “Detector Emulator”.

4. Configure the fields similarly to the screenshot:

   • Time
     • N Samples: 10000 (the total number of samples to generate)
     • N Events: 10 (how many pulses you want)
     • Event distribution: Fixed Rate
     • Rate: 50000 Hz (controls how close pulses occur in time)
     • Delay: 0 µs (optional offset)
   • Shape
     • Tau (µs): 1
       (the exponential decay constant of the simulated preamp)
     • Rise Time (µs): 0.01
       (fast leading edge)
     • AC Coupling (Hz): 0
       (no AC offset removal)
   • Amplitude
     • Polarity: Positive
     • Modulation: Fixed
     • Amplitude (ADC): 2000 (peak height in ADC counts)
   • Spectrum File: (leave blank)
   • Amplitude Gain: 1
   • DC Offset (ADC): 0
   • Noise: 0 (for a cleaner test)

Meaning of Each Field:

• N Samples: length of the simulated buffer in total data points.
• N Events: how many pulses to insert within those samples.
• Rate (Hz): approximate repetition rate of pulses.
• Tau (µs): decay time constant for the preamp output.
• Rise Time (µs): how quickly the pulse rises.
• Amplitude (ADC): maximum pulse height (in raw counts).
• Polarity: sets pulse sign (Positive or Negative).
• Noise: can add random fluctuations if desired.

4. Running the Simulation

1. Go to Simulation → Run Simulation.
2. Sci‐Compiler will synthesize the blocks, compile them, and run a testbench behind the scenes.
3. After it finishes, open GTKWave via View → Waveform Results.

5. Observing the Waveforms in GTKWave

In the GTKWave window:

• A0[15:0]: The raw exponential pulses from the Detector Emulator.
• P_dk[15:0]: The first difference signal. It spikes up at each rising edge and returns to near zero.
• P_dkl[15:0]: The second difference signal, shaping the flat top or the next stage.
• P_p[31:0]: The partial accumulation of the difference (often a ramp‐like or trapezoid shape).
• P_r[31:0]: Another partial sum or offset.
• P_s[63:0]: The final shaped output (the fully formed trapezoid).

You’ll see pulses that rise to a certain amplitude, hold for some samples (depending on the filter’s parameters), and then return to baseline. If M was applied for exponential correction, you should see a relatively symmetric trapezoid rather than one with a long tail.

Guide to Viewing and Customizing Signals in GTKWave

If you have never used GTKWave before, here is a detailed step‐by‐step procedure to load, visualize, and customize your waveforms. Once your Sci‐Compiler simulation finishes and you select View Waveform Results, GTKWave will open with your trace file.

1. Adding Signals to the Waveform Viewer

1. Initial Window
   When GTKWave opens, you’ll typically see three main sections:

   • Left Panel (Hierarchy/Signals Browser): A tree or list containing all available signals.
   • Center Panel (Waveform Display): Where signals are actually plotted.
   • Bottom Panel (Console / Status): Log or messages.

2. Find Your Signals

   • In the Hierarchy or Signals tab on the left side, navigate until you see the signals you want (e.g., A0[15:0], p_dk[15:0], etc.).
   • Each signal might appear under modules or scoping (e.g., top → design → signals).

3. Add Them to the Waveform Display

   • Method A: Double‐click a signal in the left panel to add it to the center panel.
   • Method B: Select the signal(s) with your mouse, then click the Insert or Append button near the top of the left panel.
   • Method C: Right‐click the signal and choose “Send to Waveform” or “Append”.

After this step, the selected signals appear in the main waveform area.

2. Setting the Display Format to Signed Decimal

GTKWave can display your data in binary, hex, decimal, or other formats. For signals representing signed 16‐bit or 32‐bit values, we often want signed decimal. To do this:

1. Right‐Click the signal name in the center (waveform list area, not the wave diagram).
2. Choose “Data Format…” .
3. Select Signed Decimal.

Repeat this for each signal you want to see in signed decimal form. You can do the same for signals that are 32‐bit or 64‐bit accumulators.

3. Changing the Waveform Style to “Analog Step”

For integer signals, GTKWave defaults to a digital line or stepped wave. If you prefer a more analog‐like representation:

1. Right‐Click the signal name again in the center list.
2. Data Format → “Analog” → “Step”.
   • “Analog Step” makes it look like a real waveform with steps at each clock.
   • Alternatively, “Analog Interp” tries to interpolate between sample points (less common for digital logic).

The waveform in the display will now appear as a stepped analog line.

4. Adjusting the Vertical Scale (Analog Height)

When viewing signals in “Analog” mode, you can control how tall each signal is drawn:

1. Right‐Click the signal name.
2. Look for “Insert Analog Height Extension” to increase plot height.
3. Repeat for each signal you want to enlarge.

Tip: If you want to see two signals very clearly, you can give them each a height of 2 or more. If you have many signals, you might leave some at height 1 to save space.

5. Zoom Controls

When GTKWave first opens, it can be highly zoomed in, so you might only see a tiny fraction of your data. To fix this:

1. In the main toolbar, click “Zoom Out” (the minus magnifying‐glass icon).
2. Keep clicking until you see the entire wave or a sufficient portion of it.
3. Tip: You can also drag the horizontal scrollbar or select a region with your mouse (by dragging across the waveform) and then choose Zoom to Selected Region from the right‐click menu.