CANDOR_DAQ_PulseShapeDiscriminationAlgorithm.pdf

A Neutron Pulse Shape Discrimination (PSD) Algorithm, Detailed Description

NIST Center for Neutron Research

Revision A

March 9, 2015

Table of Contents

1. Revision History

2. Introduction

3. Memory Registers

4. State Machine Description

1. Revision History

Revision Reason for Revision Date Author Revision A Initial Document Release March 9, 2015 Kevin Pritchard

2. Introduction

A digital Pulse Shape Discrimination (PSD) algorithm has been developed to discern between neutron waveforms and non-neutron waveforms (thermal noise, gamma radiation, etc.) in a detector system using a LiF:ZnS(Ag) detector/scintillator with wavelength shifting (WLS) fibers. The detector couples to a silicon photomultiplier (SiPM) for electrical readout of the optical signal. Neutrons have a longer decay time than other forms of radiation and noise. This aspect can be used to differentiate neutrons in a digital signal processing approach.

Figure 1: Examples of neutron (blue) and gamma (green) pulse waveforms

Figure 2: A State Flow Diagram of the neutron discrimination algorithm

3. Memory Registers

Three static memory parameters can be changed at run-time from a PC:

trigger_threshold_reg is the trigger parameter mentioned in Section 4 under MONITOR_FOR_PULSE.

This is a trigger level setting for noise rejection.

rising_edge_threshold_reg is a secondary trigger parameter mentioned in Section 4 under PULSE_EVENT_BEGIN. This parameter is for detecting the edge of a pulse front, and beginning the PSD sequence.

tail_integration_threshold_reg is the main threshold setting for neutron vs. noise discrimination. This is described in Section 4 under DISCRIMINATE_NEUTRON.

A number of dynamic variables are based on the incoming data:

moving_sum is a digitally filtered version of the input data.

data_delayed is a delayed version of the input data.

prompt_integration_reg is the sum of ADC values for the first ~400ns following the pulse edge tail_integration_reg is the sum of ADC values from 400ns - 1000ns following the pulse edge cooloff_threshold_reg is the adaptive cooloff profile that is initialized to ½ of the tail_integration_reg value following a neutron event.

accumulator_value is a register for temporarily storing summation values. These values are copied to prompt_integration_reg and tail_integration_reg as the PSD sequence advances.

4. State Machine Description

INITIALIZATION:

On power up or reset, the discriminator waits 500ns before beginning normal operation. This gives the system time to initialize.

MONITOR_FOR_PULSE:

While waiting for an incoming pulse to examine, the discriminator state machine will be in state MONITOR_FOR_PULSE. While in MONITOR_FOR_PULSE, the state machine examines the moving_sum variable. Moving_sum is a filtered version of the input, and it is used to reject shot noise from the SiPM photodetector. Only pulses of significant size will trigger examination by the discriminator. If the moving_sum variable exceeds trigger_threshold_reg, then the discriminator state machine will advance to state PULSE_EVENT_BEGIN. See figure 1. In effect, moving_sum is a digital filter. If the SiPM dark noise is at a sufficiently low level, so that deadtime caused by evaluating frequent, minor noise pulses is negligible, then the digital filter could be removed to simplify the PSD algorithm for a scaled up system.

Figure 3: Raw and filtered incoming data (top); Edge detection, prompt integration, and tail integration (bottom)

PULSE_EVENT_BEGIN:

After a sufficiently large pulse has been detected, a delayed version of the input waveform is evaluated.

The waveform is delayed by 320ns. The algorithm looks for a rising edge, and then evaluates the pulse beginning from the pulse edge. After a pulse edge is sensed, the state machine advances to

PROMPT_INTEGRATION.

PROMPT_INTEGRATION:

The delayed waveform is fed into an accumulator to integrate for a set period of time. For a faster SiPM, with an 80ns pixel decay time, the PROMPT_INTEGRATION_TIME period is 160ns. For a slower SiPM with 200ns pixel decay time, PROMPT_INTEGRATION_TIME period is 400ns. The accumulator value is stored in the prompt_integration_reg variable. The state machine automatically advances to

CLEAR_ACCUM.

CLEAR_ACCUM:

After the pulse waveform has been integrated following the rising edge, the prompt_integration_reg variable is latched, and the accumulator is cleared. The state machine automatically advances to

TAIL_INTEGRATION.

TAIL_INTEGRATION:

The second half of the pulse waveform is integrated by the accumulator. The accumulator value is stored in the tail_integration_reg variable. The TAIL_INTEGRATION_TIME period is constant, but this constant could be changed to a duration somewhere between 400ns to 1000ns depending on the design goals of the algorithm (dead-time, dark-noise rejection, prompt-to-tail ratio, etc.). The state machine automatically advances to DISCRIMINATE_NEUTRON.

DISCRIMINATE_NEUTRON:

A Pulse Shape Discrimination (PSD) algorithm uses the pulse shape to identify neutron pulses. Ideally, a neutron region can be defined, such that an enclosed area in prompt integration / tail integration space is defined, and all pulses with a tail/prompt ratio falling within this closed region are neutrons, and everything else is noise (thermal, electrical, gamma). The ideal situation, illustrated on the top is certainly achievable. However, for the sake of saving development time and FPGA resources, the illustration on the bottom shows what is being evaluated in the current PSD algorithm.

Figure 4: The ideal neutron region.

Figure 5: A computationally compact approximation of the neutron region.

Currently, the tail_integration_reg must exceed tail_integration_threshold_reg, a runtime definable threshold. In addition, the ratio of tail_integration_reg to prompt_integration_reg must be greater than 1:2. Comparisons of prompt/tail ratio are easy and consume minimal logic resources when the ratios are ¼, ½, 1, 2, 4, etc; powers of 2. Just an omission of least significant bits is required. This is a good enough comparison to eliminate large gamma pulses with after pulses from being identified as false neutrons. However, subtler noise, or EMI noise may not be correctly discriminated. You may notice that under the current algorithm, when the preamplifier is disconnected from the discriminator, a DC bias is present on the ADC input, and the discriminator will count spontaneously! This is because a positive DC voltage trips the moving_sum_threshold_reg, exceeds the rising_edge_threshold_reg, and then falls within the currently defined Neutron Region!

Fixing this shortcoming is a low risk exercise, but it will require development time. The ideal case would require the instantiation of multipliers in the FPGA, which are large structures. Calibration firmware and software would need to be developed in order to export a dataset of prompt and tail integration values to a PC, and then compute ratios which define the neutron region. If digital PSD is a technology that we choose for instrument level scale-up, this development work can be done. A calibration program can be developed which will be robust against DC offsets, changes in gain, and all forms of noise which lie outside the defined neutron region. Regardless of DC offset, preamp gain, and SiPM overvoltage, the neutron region can be computed. FPGA implementation is not required for this algorithm either. A microcontroller architecture could do the same thing.

At this point, the algorithm branches, depending on whether the pulse waveform is identified as a neutron or as a gamma/noise. If the pulse is not a neutron, then the state machine advances to MONITOR_FOR_PULSE. If the pulse is a neutron, then the state machine advances to

NEUTRON_DEAD_TIME.

NEUTRON_DEAD_TIME:

The state machine holds in NEUTRON_DEAD_TIME for 1.5µs. During this time, the state machine outputs a logic pulse. After the 1.5µs deadtime, the state machine advances to ADAPTIVE_COOLOFF.

ADAPTIVE_COOLOFF:

Figure 6: Adaptive Cooloff profile

After a 1.5us deadtime, there is an additional 26.5us ADATPTIVE_COOLOFF_TIME. During ADAPTIVE_COOLOFF, if the moving_sum exceeds the adaptive cooloff profile, which is stored in the cooloff_threshold_reg variable, then the state machine treats this as a new incoming pulse. The state machine advances to MONITOR_FOR_PULSE and the process repeats. If the ADAPTIVE_COOLOFF_TIME is exceeded, then the state machine advances to MONITOR_FOR_PULSE anyway.

The cooloff_threshold_reg variable starts as ½ of the tail_integration_reg value (tail_integration_reg is merely shifted by one bit and loaded into cooloff_threshold_reg). From there on, cooloff_threshold_reg decays linearly. 1/32 of the tail_integration_reg value (five bit shifts) is subtracted every 1200ns from cooloff_threshold_reg. This is a logically compact way to do adaptive cooloff in an FPGA. Microcontrollers may allow more flexibility, although the described adaptive cooloff profile appears to be sufficient.