Core classes architecture

The core classes reproduce the GET system architecture:

• the full system (GETSystem) and specific classes defining existing systems such as the "Reduced CoBo" test system (class GETRCoBo) or the ACTAR TPC demonstrator system (class GETActarDem);
• the CoBo modules (GETCoBo) controlling 4 AsAd boards;
• the AsAd boards (GETAsAd) that contain 4 AGet chips and the analog to digital converter;
• the AGet chips (GETAGet) that has 68 channels: 64 signal channels and 4 FPN (Fix Pattern Noise) channels;
• the AGet channels (GETChannel) that can process either the signal samples from real measurements, or from simulations.

At this stage, there is no class defined for the MUTANT trigger module.

These classes all inherit from the base class GETObject that manages the filiation between core objects.

This base class also defines properties that can be common to the object and its filiation, like response functions, filters or output noise generators.

The GETSystem class: defining GET architecture

A GETSystem object must be created to define the full GET system architecture: it creates the CoBo modules, controlling the AsAd boards that hold the AGet chips where data channels are defined.

The GETRCoBo class inherits from the GETSystem class, but it contains only 1 CoBo module controlling only 1 AsAd board. The GETActarDem class also inherits from the GETSystem class, and it contains 2 CoBo modules (with 4 AsAd each).

A very basic code to define a system (with 2048 channels) that reads events from a data file is given below:

// includes from GET library
#include "GETSystem.hh"

// read events program
int main ( int argc, char **argv )
{
  GSetVerboseLevel(6);

 // create the system: the GETActarDem object is a GETSystem
 // object with 2 CoBo / 8 AsAd, a sample depth of 512 time buckets
 // and a write frequency of 50 MHz (period 0.02 us).
 GETSystem system ( 2, 512, 0.02 );

 // open a test data file
 system.OpenRunFile ( "my_run_data_file" );

 // read single events until end of file (no processing of signal)
 while (system.ReadEvent ( false ) != -1) { }

 // close the events file
 system.CloseRunFile ( );
 return (0);
}

The GETChannel class: defining the data samples

The GETChannel class is the basic element for GET signal processing. It defines one channel of the electronics system, that receives an input signal from the detector, transforms it from the amplification chain, and samples the result.

For analysis, the GETChannel class stores the signal data as samples (array of signal values from the time sampling):

• the input sample: it represents the input signal of the AGet channel, collected signal from a detector channel
  • for a real experiment, it is not known;
  • for a simulation, it is defined by the charge collection of the simulation
• the output sample: it is the result of the processing of the input signal
  • for an experiment, it is read from experimental data file;
  • for a simulation, it results from the simulated input sample processed by the AGet channel response function.
• the reconstructed sample: it represents the estimate of the input sample, reconstructed from inverse processing of the output sample by the AGet channel response function.

Since the processing of signal samples takes advantage of Fast Fourier Transforms (FFT), the samples are defines as RRealSamplesFFT objects of the GFFT library.

For the signal processing classes, see Signal processing classes.