#include <PndDiscNoiseGeneration.h>

Public Member Functions
	PndDiscNoiseGeneration ()

	~PndDiscNoiseGeneration ()

void	SetNumberOfSensors (int n_detectors_, int n_readout_modules_, int n_sensors_)
	Set the number of sensors for the whole apparatus. More...

void	SetSensorGrid (double sensor_width_, double sensor_height_, int n_pixel_x_, int n_pixel_y_)
	Set the pixel grid on the sensors. More...

void	SetSensorTiling (int sensor_tiles_x, int sensor_tiles_y)
	Set a logical tiling (used for dead time handling) More...

void	SetPerCellDCR (double dcr_Hz)

int	GenerateNoise (double t_start_ns, double t_end_ns)
	Generate noise pattern in time window given by t_start, t_end. More...

PndDiscDigitizedHit *	GetNextNoiseDigit ()
	Iterate over all generated hits. More...

void	Clear ()
	Clears the digit buffer. More...

Protected Attributes
TClonesArray *	noise_digits
	Memory pool to store the digits. More...

int	current_index
	current index in pool (used in iteration) More...

int	n_detectors
	number of detectors More...

int	n_readout_modules
	number of readout modules on a detector More...

int	n_sensors
	number of sensors (untiled) at a readout module More...

int	n_sensor_tiles_x
	number of sensor tiles = number of dies More...

int	n_sensor_tiles_y
	number of sensor tiles = number of dies More...

double	half_sensor_width

double	half_sensor_height

int	n_pixel_x

int	n_pixel_y

int	n_pixel_total

double	pitch_x

double	pitch_y

double	dcr_per_pixel

Private Member Functions
bool	GetPixelPosition (int n_pixel, double &pos_x, double &pos_y)

Detailed Description

Definition at line 19 of file PndDiscNoiseGeneration.h.

Constructor & Destructor Documentation

PndDiscNoiseGeneration::PndDiscNoiseGeneration ( )

Definition at line 23 of file PndDiscNoiseGeneration.cxx.

References noise_digits.

     : current_index(0), n_detectors(0), n_readout_modules(0), n_sensors(0),
       n_sensor_tiles_x(1), n_sensor_tiles_y(1),
       half_sensor_width(1.0), half_sensor_height(1.0),
       n_pixel_x(1), n_pixel_y(1), pitch_x(1.0), pitch_y(1.0),
       dcr_per_pixel(0.0)
 {
     noise_digits = new TClonesArray("PndDiscDigitizedHit");
 }

PndDiscNoiseGeneration::~PndDiscNoiseGeneration ( )

Definition at line 34 of file PndDiscNoiseGeneration.cxx.

References noise_digits.

                                                 {
     if(noise_digits != NULL) delete noise_digits;
 }

Member Function Documentation

void PndDiscNoiseGeneration::Clear ( )

Clears the digit buffer.

Definition at line 127 of file PndDiscNoiseGeneration.cxx.

References current_index, and noise_digits.

Referenced by GenerateNoise().

                                    {
     noise_digits->Clear();
     current_index = 0;
 }

int PndDiscNoiseGeneration::GenerateNoise	(	double	t_start_ns,
		double	t_end_ns
	)

Generate noise pattern in time window given by t_start, t_end.

Definition at line 77 of file PndDiscNoiseGeneration.cxx.

References Clear(), dcr_per_pixel, GetPixelPosition(), half_sensor_height, half_sensor_width, hit, n_detectors, n_pixel_x, n_readout_modules, n_sensor_tiles_x, n_sensor_tiles_y, n_sensors, and noise_digits.

                                                                             {
     Clear(); // clear buffer and reset the counter
 
     // fill buffer with new noise digits
     double n_hits_avg = dcr_per_pixel * (t_end_ns - t_start_ns); // average number of hits in time window
 
     // compute the tile pitch
     double tile_pitch_x = half_sensor_width *2.0 / double(n_sensor_tiles_x);
     double tile_pitch_y = half_sensor_height*2.0 / double(n_sensor_tiles_y);
 
     // loop over all sensors:
     int n_pixel, n_hits, hit, n_total_hits = 0;
     int sensor_nx, sensor_ny, detector_id, readout_id, sensor_id, sensor_vid;
     double hit_time, pos_x, pos_y;
 
     for(detector_id=0; detector_id<n_detectors; detector_id++) {
         for(readout_id=0; readout_id < n_readout_modules; readout_id++) {
             for(sensor_vid=0; sensor_vid<n_sensors; sensor_vid++) {
                 // loop over all pixels of the sensor:
                 for(n_pixel=0; GetPixelPosition(n_pixel, pos_x, pos_y); n_pixel++) {
                     // compute the sensor identifier (tile grouping for dead time handling):
                     sensor_nx = (int)(pos_x + half_sensor_width)/tile_pitch_x;
                     sensor_ny = (int)(pos_y + half_sensor_height)/tile_pitch_y;
                     //sensor_nx = (pos_x < 0 ? 0 : 1);
                     //sensor_ny = (pos_y < 0 ? 0 : 1);
                     sensor_id = sensor_vid*(n_sensor_tiles_x*n_sensor_tiles_y) + sensor_ny*(n_sensor_tiles_x) + sensor_nx + 1;
 
                     // compute number of hits and distribute these in the time window:
                     n_hits = gRandom->Poisson(n_hits_avg); // hits on this pixel in the given time window
                     for(hit=0; hit < n_hits; hit++) {
                         hit_time = gRandom->Uniform(t_start_ns, t_end_ns);
                         // store noise hit:
                         new ((*noise_digits)[n_total_hits++]) PndDiscDigitizedHit(FairLink(), detector_id, readout_id, sensor_id, sensor_id, n_pixel/n_pixel_x, pos_y, hit_time, hit_time, 1);
                     }
                 }            
             }
         }
     }
     return noise_digits->GetEntries();
 }

PndDiscDigitizedHit * PndDiscNoiseGeneration::GetNextNoiseDigit ( )

Iterate over all generated hits.

Definition at line 119 of file PndDiscNoiseGeneration.cxx.

References current_index, and GetEntries().

                                                                 {
     if(current_index < noise_digits->GetEntries()) 
         return (PndDiscDigitizedHit*)(*noise_digits)[current_index++];
     else
         return NULL;
 }

bool PndDiscNoiseGeneration::GetPixelPosition	(	int	n_pixel,
		double &	pos_x,
		double &	pos_y
	)

private

Definition at line 69 of file PndDiscNoiseGeneration.cxx.

References half_sensor_height, half_sensor_width, n_pixel_total, n_pixel_x, pitch_x, and pitch_y.

Referenced by GenerateNoise().

                                                                                          {
     if(n_pixel >= n_pixel_total) return false;
     pos_x = -half_sensor_width  + (double(n_pixel % n_pixel_x)+0.5) * pitch_x;
     pos_y = -half_sensor_height + (double(n_pixel / n_pixel_x)+0.5) * pitch_y;
     return true;
 }

void PndDiscNoiseGeneration::SetNumberOfSensors	(	int	n_detectors_,
		int	n_readout_modules_,
		int	n_sensors_
	)

Set the number of sensors for the whole apparatus.

Definition at line 39 of file PndDiscNoiseGeneration.cxx.

References n_detectors, n_readout_modules, and n_sensors.

                                                                                                         {
         // note: a sensor can also be tiled - this is actually the sensitive area at a focusing element.
         n_detectors = n_detectors_;
         n_readout_modules = n_readout_modules_;
         n_sensors = n_sensors_;
 }

void PndDiscNoiseGeneration::SetPerCellDCR ( double dcr_Hz )

inline

Definition at line 33 of file PndDiscNoiseGeneration.h.

References dcr_per_pixel.

33 { dcr_per_pixel = dcr_Hz*1E-9; }

PndDiscNoiseGeneration::dcr_per_pixel

double dcr_per_pixel

Definition: PndDiscNoiseGeneration.h:62

void PndDiscNoiseGeneration::SetSensorGrid	(	double	sensor_width_,
		double	sensor_height_,
		int	n_pixel_x_,
		int	n_pixel_y_
	)

Set the pixel grid on the sensors.

Definition at line 47 of file PndDiscNoiseGeneration.cxx.

References half_sensor_height, half_sensor_width, n_pixel_total, n_pixel_x, n_pixel_y, pitch_x, and pitch_y.

 {
     half_sensor_width  = 0.5*sensor_width_;
     half_sensor_height = 0.5*sensor_height_;
     n_pixel_x = n_pixel_x_;
     n_pixel_y = n_pixel_y_;
 
     pitch_x = sensor_width_  / double(n_pixel_x);
     pitch_y = sensor_height_ / double(n_pixel_y);
 
     n_pixel_total = n_pixel_x * n_pixel_y;
 
 }

void PndDiscNoiseGeneration::SetSensorTiling	(	int	sensor_tiles_x,
		int	sensor_tiles_y
	)

Set a logical tiling (used for dead time handling)

Definition at line 63 of file PndDiscNoiseGeneration.cxx.

References n_sensor_tiles_x, and n_sensor_tiles_y.

                                                                                    {
     n_sensor_tiles_x = sensor_tiles_x;
     n_sensor_tiles_y = sensor_tiles_y;
 }