source: trunk/MagicSoft/Simulation/Detector/include-MFadc/MFadc.cxx@ 5099

////////////////////////////////////////////////////////////////
//
//  MFadc
//
//  
#include "MFadc.hxx"

#include "MMcEvt.hxx"

#include "TROOT.h"
#include <TApplication.h>
#include <TVirtualX.h>
#include <TGClient.h>

#include "TH1.h"
#include "TObjArray.h"

#include "MGFadcSignal.hxx"

using namespace std;

MFadc::MFadc(Int_t pix, Int_t shape, Float_t integral, Float_t fwhm, Int_t shapeout, Float_t integralout, Float_t fwhmout, Float_t trigger_delay) {
  //
  //  Constructor overloaded II 
  //  
  //  Input variables:
  //  1. integral(out) = integration of the single phe response for inner 
  // (outer) pixels.
  //  2. fwhm(out) = width at half high of the single phe response for
  // inner (outer) pixels.
  //
  // trigger_delay: shift of signals towards later times in FADC, in order
  // to center the signals in a good range. It acts as a sort of delay of 
  // the signals (before being sent to the FADC) with respect to the trigger.
  //
  //  The procedure is the following: 
  //  1. some parameters of the trigger are set to default.   
  //     this parameters of the trigger may be changed
  //  3. Then the all signals are set to zero

  numpix=pix;
  
  fwhm_resp = fwhm; 
  integ_resp = integral; 
  fwhm_resp_outer = fwhmout; 
  integ_resp_outer = integralout; 
  shape_resp=shape;
  shape_resp_outer=shapeout;

    cout<< "[MFadc]  Setting up the MFadc with this values "<< endl ; 
    cout<< "[MFadc]    - Inner pixels :  "<< endl ; 
  switch(shape_resp){
  case 0:
    cout<< "[MFadc]       Pulse shape   : Gaussian ("<<shape_resp<<")"<< endl ; 
    cout<< "[MFadc]       Response Area : "<<integ_resp<<" adc counts"<< endl ; 
    cout<< "[MFadc]       Response FWHM : "<<fwhm_resp<<" ns"<< endl ; 
    break;
  case 1:
    cout<< "[MFadc]       Pulse shape   : From Pulpo ("<<shape_resp<<")"<< endl ; 
    cout<< "[MFadc]       Response Area : "<<integ_resp<<" adc counts"<< endl ; 
    break;
  default:
    cout<< "[MFadc]       Pulse shape unknown"<<endl;
  }
  cout<< "[MFadc]    - Outer pixels :  "<< endl ; 
  switch(shape_resp_outer){
  case 0:
    cout<< "[MFadc]       Pulse shape   : Gaussian ("<<shape_resp_outer<<")"<<endl; 
    cout<< "[MFadc]       Response Area : "<<integ_resp_outer<<" adc counts"<<endl; 
    cout<< "[MFadc]       Response FWHM : "<<fwhm_resp_outer<<" ns"<< endl ; 
    break;
  case 1:
    cout<< "[MFadc]       Pulse shape   : From Pulpo ("<<shape_resp_outer<<")"<<endl;
    cout<< "[MFadc]       Response Area : "<<integ_resp_outer<<" adc counts"<< endl ;
    break;
  default:
    cout<< "[MFadc]       Pulse shape unknown ("<<shape_resp_outer<<")"<<endl;
  }

  
  //
  //    set up the response shape
  // 
  Int_t  i ;
  
  Float_t   sigma ; 
  Float_t   x, x0 ; 
  Float_t   dX, dX2 ; 

  Float_t   response_sum_inner, response_sum_outer;
  response_sum_inner = 0.;
  response_sum_outer = 0.;

  dX  = WIDTH_FADC_TIMESLICE / SUBBINS ;   // Units: ns
  dX2 = dX/2. ; 

  switch(shape_resp){

  case 0:
    sigma = fwhm_resp / 2.35 ; 
    x0 = 3*sigma;
    fadc_time_offset = trigger_delay-x0; // ns
  
    for (i=0; i< RESPONSE_SLICES_MFADC ; i++ ) {  

      x = i * dX + dX2 ; 
      
      sing_resp[i] = expf(-0.5 * (x-x0)*(x-x0) / (sigma*sigma) ) ; 

      response_sum_inner += sing_resp[i];
    }

    break;
  case 1:
    float p1,p2,p3,p4,p5,p6,p7;
    float d;
    float zed_slices;
    // Parameters values extracted from fitting a real FADC response
    // gaussian electronic pulse passed through the whole chain from 
    // transmitter boards to FADC.
    p1 = 2.066; 
    p2 = 1.568; 
    p3 = 3; // This sets the peak of the pulse at x ~ 3 ADC slices
            // It is just a safe value so that the pulse is well contained.
    p4 = 0.00282; 
    p5 = 0.04093; 
    p6 = 0.2411; 
    p7 = -0.009442;
    // Define the time before trigger to read FADC signal when it
    //  has to be written
    fadc_time_offset = trigger_delay-p3*WIDTH_FADC_TIMESLICE; // ns

    for (i=0; i< RESPONSE_SLICES_MFADC ; i++ ) {  
      x = i * dX + dX2;

      // x has to be converted from ns to units FADC slices:
      zed_slices=x/WIDTH_FADC_TIMESLICE-p3;
      d=(zed_slices>0)?0.5:-0.5;

      sing_resp[i] =  (p1*exp(-p2*(exp(-p2*zed_slices)+zed_slices))+p4+
                       p5*exp(-p2*(exp(-p2*zed_slices)+p6*zed_slices))+p7*d);

      response_sum_inner += sing_resp[i];
    }

    break;
  default:
    cout<<"[MFadc] MFadc::MFadc : Shape of FADC pulse for inner pixel unknown."
        <<endl;
    cout<<"[MFadc] MFadc::MFadc : Exiting Camera ..."
        <<endl;
    exit(1);
  } 

  // Response for outer pixels

  switch(shape_resp_outer){

  case 0:
    sigma = fwhm_resp_outer / 2.35 ; 
    x0 = 3*sigma ; 
    fadc_time_offset = trigger_delay-x0; // ns
    
    for (i=0; i< RESPONSE_SLICES_MFADC ; i++ ) {  
      
      x = i * dX + dX2 ; 
      
      //
      //   the value 1/sqrt(2*Pi*sigma^2) was introduced to normalize 
      //   the area at the input value After this, the integral
      //   of the response will be integ_resp.
      //
      sing_resp_outer[i] = expf(-0.5 * (x-x0)*(x-x0) / (sigma*sigma) ) ; 
      response_sum_outer += sing_resp_outer[i];
    } 
    break;
  case 1:
    float p1,p2,p3,p4,p5,p6,p7;
    float d;
    float zed_slices;
    // Parameters values extracted from fitting a real FADC response
    // gaussian electronic pulse passed through the whole chain from 
    // transmitter boards to FADC.
    p1 = 2.066; 
    p2 = 1.568; 
    p3 = 3; // This sets the peak of the pulse at x ~ 3 ADC slices
               // It is just a safe value so that the pulse is well contained.
    p4 = 0.00282; 
    p5 = 0.04093; 
    p6 = 0.2411; 
    p7 = -0.009442;
    // Define the time before trigger to read FADC signal when it
    //  has to be written
    fadc_time_offset = trigger_delay-p3*WIDTH_FADC_TIMESLICE; // ns

    for (i=0; i< RESPONSE_SLICES_MFADC ; i++ ) {  
      x = i * dX + dX2;

      zed_slices=x/WIDTH_FADC_TIMESLICE-p3;
      d=(zed_slices>0)?0.5:-0.5;

      sing_resp_outer[i] = (p1*exp(-p2*(exp(-p2*zed_slices)+zed_slices))+p4+
                            p5*exp(-p2*(exp(-p2*zed_slices)+p6*zed_slices))+p7*d);
      response_sum_outer += sing_resp_outer[i];
      }
    break;
  default:
    cout<<"[MFadc] MFadc::MFadc : Shape of FADC pulse for inner pixel unknown."
        <<endl;
    cout<<"[MFadc] MFadc::MFadc : Exiting Camera ..."
        <<endl;
    exit(1);
  }

  //   
  // Normalize responses to values set trhough input card: (= set gain of electronic chain)
  // Take into account that only 1 of every SUBBINS bins of sing_resp[] will be "sampled" by 
  // the FADC, so we have to correct for this to get the right "FADC integral" (=integ_resp) 
  // per photoelectron:
  //

  for (i=0; i< RESPONSE_SLICES_MFADC ; i++ ) {  
      sing_resp[i] *= integ_resp / response_sum_inner * SUBBINS;
      sing_resp_outer[i] *= integ_resp_outer / response_sum_outer * SUBBINS;
  }

  //
  //    init the Random Generator for Electonic Noise
  //

  GenElec = new TRandom () ; 

  Reset();

  //
  //  set all pedestals to 0
  //
  
  for ( i =0 ; i <CAMERA_PIXELS ; i++ ) { 
    pedestal[i] = 0.0 ; 
  }

  cout<<" end of MFadc::MFadc()"<<endl;
}
  
void MFadc::Reset() { 
    //
    //  set all values of the signals to zero
    //  set the values of FADC slices that would be read after trigger to zero
    //
    memset(used, 0, CAMERA_PIXELS*sizeof(Bool_t));
    memset(output, 0, CAMERA_PIXELS*FADC_SLICES*sizeof(Float_t));
    memset(output_lowgain, 0, CAMERA_PIXELS*FADC_SLICES*sizeof(Float_t));
    // 
    // Added 15 01 2004, AM:
    //
    memset(sig, 0, (Int_t)(CAMERA_PIXELS*SLICES_MFADC*sizeof(Float_t)));
}
void MFadc::Fill( Int_t iPix, Float_t time, 
                  Float_t amplitude, Int_t isinner ) { 

    // AM, Jan 2004 : added delay to shift the signal peak to the desired
    // range in the FADC window (indicated through the trigger_delay command
    // in the camera input card.

  time += fadc_time_offset;

  if(isinner)
    Fill(iPix, time, amplitude);
  else
    FillOuter(iPix, time, amplitude);

}
void MFadc::Fill( Int_t iPix, Float_t time, Float_t amplitude ) { 
  
  //
  // fills the information about one single Phe in the Trigger class
  //
  // parameter is the number of the pixel and the time-difference to the
  // first particle
  //
  //

  Int_t i, ichan, ichanfadc ; 
  
  //
  //   first we have to check if the pixel iPix is used or not until now
  //   if this is the first use, reset all signal for that pixels
  // 
  if ( iPix > numpix ) {
    cout << " WARNING:  MFadc::Fill() :  iPix greater than Pixels in Camera = "
         << numpix
         << endl ;
    exit(987) ; 
  }

  if ( used[iPix] == FALSE ) {
    used [iPix] = TRUE ; 
    
    for (i=0; i < (Int_t) SLICES_MFADC; i++ ) {
      sig[iPix][i] = 0. ; 
    }
  }

  //
  //   then select the time slice to use (ican) 
  // 

  if ( time < TOTAL_TRIGGER_TIME+fadc_time_offset ) { 
    //
    //   determine the slices number assuming the WIDTH_RESPONSE_MFADC
    //   ichan marks the start of the pulse, in number of bins of width  
    //   WIDTH_RESPONSE_MFADC (2/3 of a ns), measured from the start of the 
    //   FADC.
    //

    ichan = (Int_t) ( time / ((Float_t) WIDTH_RESPONSE_MFADC )); 

    //
    //   putting the response slices in the right sig slices.
    //   Be carefull, because both slices have different widths. 
    //

    //
    // AM, Jan 2004: Replaced former FADC simulation (integration of signal)
    // with a more realistic one (measuring signal height at discrete points).
    //

    // We take the pulse height in the middle of FADC slices, we start in the
    // first such point after the time "time" (=ichan in response bins). Each
    // FADC slice corresponds to SUBBINS response bins (SUBBINS=5 by default).

    Int_t first_i =  Int_t(SUBBINS/2) - ichan%(Int_t)SUBBINS;
    first_i = first_i < 0 ? (Int_t)SUBBINS+first_i : first_i;


    for ( i = first_i ; i < (Int_t)RESPONSE_SLICES; i += (Int_t)SUBBINS) {      
      ichanfadc = (Int_t) ((ichan+i)/SUBBINS) ; 
      if ( ichanfadc < 0 )
          continue;

      //
      // SLICES_MFADC is by default 48. sig[][] is not the true FADC, which
      // is filled from sig[][] in MFadc::TriggeredFadc()
      //
      if ( (ichanfadc) < (Int_t)SLICES_MFADC ) {  
        sig[iPix][ichanfadc] += (amplitude * sing_resp[i] )  ; 
      } 
    }

  }
  else {
    cout << "  WARNING!  Fadc::Fill " << time << "  out of TriggerTimeRange " 
         << TOTAL_TRIGGER_TIME+fadc_time_offset << endl ; 
  }

}

void MFadc::FillOuter( Int_t iPix, Float_t time, Float_t amplitude ) { 
  
  //
  // fills the information about one single Phe in the Trigger class
  // for an outer pixel
  //
  // parameter is the number of the pixel and the time-difference to the
  // first particle
  //
  //

  Int_t i, ichan, ichanfadc ; 
  
  //
  //   first we have to check if the pixel iPix is used or not until now
  //   if this is the first use, reset all signal for that pixels
  // 
  if ( iPix > numpix ) {
    cout << " WARNING:  MFadc::FillOuter() :  iPix greater than CAMERA_PIXELS"
         << endl ;
    exit(987) ; 
  }

  if ( used[iPix] == FALSE ) {
    used [iPix] = TRUE ; 
    
    for (i=0; i < (Int_t) SLICES_MFADC; i++ ) {
      sig[iPix][i] = 0. ; 
    }
  }

  //
  //   then select the time slice to use (ican) 
  // 


  if ( time < TOTAL_TRIGGER_TIME+fadc_time_offset ) { 
    //
    //   determine the slices number assuming the WIDTH_RESPONSE_MFADC
    //
    ichan = (Int_t) ( time / ((Float_t) WIDTH_RESPONSE_MFADC )); 

    //
    //   putting the response slices in the right sig slices.
    //   Be carefull, because both slices have different widths. 
    //

    //
    // AM, Jan 2004: Replaced former FADC simulation (integration of signal)
    // with a more realistic one (measuring signal height at discrete points).
    //

    // We take the pulse height in the middle of FADC slices, we start in the
    // first such point after the time "time" (=ichan in response bins). Each
    // FADC slice corresponds to SUBBINS response bins (SUBBINS=5 by default).

    Int_t first_i =  Int_t(SUBBINS/2) - ichan%(Int_t)SUBBINS;
    first_i = first_i < 0 ? (Int_t)SUBBINS+first_i : first_i;

    for ( i = first_i ; i < (Int_t)RESPONSE_SLICES; i += (Int_t)SUBBINS) {
      ichanfadc = (Int_t) ((ichan+i)/SUBBINS) ; 

      if ( ichanfadc < 0 )
          continue;

      if ( (ichanfadc) < (Int_t)SLICES_MFADC ) {  
        sig[iPix][ichanfadc] += (amplitude * sing_resp_outer[i] )  ; 
      } 
    }

  }
  else {
    cout << "  WARNING!  Fadc::FillOuter " << time << "  out of TriggerTimeRange " 
         << TOTAL_TRIGGER_TIME+fadc_time_offset << endl ; 
  }

}

void MFadc::Set( Int_t iPix, Float_t resp[(Int_t) SLICES_MFADC]) { 
  
  //
  // Sets the information about fadc reponse from a given array
  //
  // parameter is the number of the pixel and the values to be set
  //
  //

  Int_t i ; 
  
  //
  //   first we have to check if the pixel iPix is used or not until now
  //   if this is the first use, reset all signal for that pixels
  // 
  if ( iPix > numpix ) {
    cout << " WARNING:  MFadc::Fill() :  iPix greater than CAMERA_PIXELS"
         << endl ;
    exit(987) ; 
  }

  if ( used[iPix] == FALSE ) {
    used [iPix] = TRUE ; 
    
    for (i=0; i < (Int_t)SLICES_MFADC; i++ ) {
      sig[iPix][i] = 0. ; 
    }
  }
  for ( i = 0 ; i<(Int_t)SLICES_MFADC; i++ ) {
    sig[iPix][i] = resp[i] ; 
  }

}

void MFadc::AddSignal( Int_t iPix, Float_t resp[(Int_t) SLICES_MFADC]) { 
  
  //
  // Adds signals to the fadc reponse from a given array
  //
  // parameters are the number of the pixel and the values to be added
  //
  //

  Int_t i ; 
  
  //
  //   first we have to check if the pixel iPix is used or not until now
  //   if this is the first use, reset all signal for that pixels
  // 
  if ( iPix > numpix ) {
    cout << " WARNING:  MFadc::Fill() :  iPix greater than CAMERA_PIXELS"
         << endl ;
    exit(987) ; 
  }

  if ( used[iPix] == FALSE ) {
    used [iPix] = TRUE ; 
    
    for (i=0; i < (Int_t)SLICES_MFADC; i++ ) {
      sig[iPix][i] = 0. ; 
    }
  }
  for ( i = 0 ; i<(Int_t)SLICES_MFADC; i++ ) {
    sig[iPix][i] += resp[i] ; 
  }

}

void MFadc::SetPedestals( Int_t ped) { 
  //  It sets pedestal for each pixel flat randomly dstributed between 0 and ped
  //  It uses the instance of TRandom GenElec.

  Int_t i;

  for(i=0;i<numpix;i++){
    pedestal[i]= (Float_t)(ped* GenElec->Rndm());
  }
}

void MFadc::SetPedestals(  Float_t *ped) { 
  //  It sets pedestal for each pixel from ped array

  Int_t i;

  for(i=0;i<numpix;i++){
    pedestal[i]= ped[i];
  }
}
  

void MFadc::Baseline(){
  //  
  //  It simulates the AC behaviour

  int i,j;
  Float_t baseline;

  for(j=0;j<numpix;j++){
    baseline=0.0;
    for(i=0;i<(Int_t) SLICES_MFADC;i++){
      baseline+=sig[j][i];
    }
    baseline=baseline/SLICES_MFADC;
    for(i=0;i<(Int_t) SLICES_MFADC;i++){
      sig[j][i]=-baseline;
    }
  }
}

void MFadc::Pedestals(){
  // 
  //  It shifts the FADC contents their pedestal values
  //  It shifts the values in the analog signal, 
  //  therefore it has to be done before getting FADC output
  //

  Int_t i, j;

  for(i=0;i<numpix;i++)
    for(j=0;j<(Int_t)SLICES_MFADC;j++)
        sig[i][j]+=pedestal[i];
  //
  // AM 15 01 2003: Formerly the above operation was performed only 
  // for pixels in which used[] was true. But to run camera with no noise
  // and get the right baseline on the pixels with no C-photons, we have 
  // to do it for all pixels.
  //


}

void MFadc::Offset(Float_t offset, Int_t pixel){
  // 
  //  It puts an offset in the FADC signal
  //

  int i,j;
  float fdum;
  TRandom *GenOff = new TRandom () ; 

  if (offset<0) {
    //  It cannot be, so the program assumes that 
    //  it should generate random values for the offset.

    if (pixel<0) {
      // It does not exist, so all pixels will have the same offset

      for(i=0;i<numpix;i++){
        if (used[i]){
          fdum=(10*GenOff->Rndm());
          for(j=0;j<(Int_t) SLICES_MFADC;j++)
            sig[i][j]+=fdum;
        }
      }
    } else {
      // The program will put the specifies offset to the pixel "pixel".

      if (used[pixel]){
        fdum=(10*GenOff->Rndm());
        for(j=0;j<(Int_t) SLICES_MFADC;j++)
          sig[pixel][j]+=fdum;
        }

    }
  }else {
    //  The "offset" will be the offset for the FADC

    if (pixel<0) {
      // It does not exist, so all pixels will have the same offset

      for(i=0;i<numpix;i++){
        if (used[i]){
          for(j=0;j<(Int_t) SLICES_MFADC;j++)
            sig[i][j]+=offset;
        }
      }
    } else {
      // The program will put the specifies offset to the pixel "pixel".

      if (used[pixel]){
        for(j=0;j<(Int_t) SLICES_MFADC;j++)
          sig[pixel][j]+=offset;
      }
    }
  }
  delete GenOff;
}

void MFadc::SetElecNoise(Float_t value1, Float_t value2, UInt_t n_in_pix){

  UInt_t i;
 
  fInnerPixelsNum = n_in_pix;

  cout<<"MFadc::SetElecNoise ... generating database for electronic noise."
      <<endl;

  for (i=0;i<(UInt_t (SLICES_MFADC))*1001;i++){
    noise[i]=GenElec->Gaus(0., value1 );
    noise_outer[i]=GenElec->Gaus(0., value2 );
  }

  cout<<"MFadc::SetElecNoise ... done"<<endl;

}

void MFadc::ElecNoise() {
  // ============================================================
  //
  //    adds the noise due to optronics and electronics 
  //    to the signal. This is noise which comes before the FADC,
  //    so it will be later scaled down in the low gain branch.
  //
  UInt_t startslice;

  for ( Int_t i = 0 ; i < numpix; i++) {
    //
    //  but at the beginning we must check if this pixel is
    //  hitted the first time
    //

    startslice=GenElec->Integer(((Int_t)SLICES_MFADC)*1000);

    if ( used[i] == FALSE )
    {
        used [i] = TRUE ; 
        if (i < fInnerPixelsNum)
            memcpy( (Float_t*)&sig[i][0],
                    (Float_t*)&noise[startslice], 
                    ((Int_t) SLICES_MFADC)*sizeof(Float_t));
        else
            memcpy( (Float_t*)&sig[i][0],
                    (Float_t*)&noise_outer[startslice], 
                    ((Int_t) SLICES_MFADC)*sizeof(Float_t));
    }

    //      
    //  If pixel already in use, the noise is added each time slice
    //
    else
    {
        if (i < fInnerPixelsNum)
            for ( Int_t is=0 ; is< (Int_t)SLICES_MFADC ; is++ ) 
                sig[i][is] += noise[startslice+is];
        else
            for ( Int_t is=0 ; is< (Int_t)SLICES_MFADC ; is++ ) 
                sig[i][is] += noise_outer[startslice+is];
    }
  }
}

void MFadc::SetDigitalNoise(Float_t value){

  UInt_t i;
  Float_t xrdm;
 
  cout<<"MFadc::SetDigitalNoise ... generating database for electronic noise."
      <<endl;

  for (i=0;i<UInt_t(SLICES_MFADC*1001);i++){
    xrdm=GenElec->Gaus(0., value);
    digital_noise[i]=(xrdm>0?Int_t(xrdm+0.5):Int_t(xrdm-0.5));    
  }
  
  cout<<"MFadc::SetDigitalNoise ... done"<<endl;

}

void MFadc::DigitalNoise() {
  // ============================================================
  //
  //    adds the noise due to FADC electronics to the signal. This
  //    noise affects equally the high and low gain branches, that is, 
  //    it is not scaled down in the low gain branch.
  //
  UInt_t startslice;

  for ( Int_t i = 0 ; i < numpix; i++) 
    {
      if ( used[i] == FALSE )
        continue;

      startslice=GenElec->Integer((Int_t) SLICES_MFADC*999);
      //      
      //  Then the noise is introduced for each time slice
      //
      for ( Int_t is=0 ; is< FADC_SLICES; is++ ) 
        { 
          output[i][is] += digital_noise[startslice+is];
          output_lowgain[i][is] += digital_noise[startslice+FADC_SLICES+is];
        }
    }
}

void MFadc::Scan() {
  

  for ( Int_t ip=0; ip<numpix; ip++ ) {
    
    if ( used[ip] == kTRUE ) {

      printf ("Pid %3d",  ip ) ; 

      for ( Int_t is=0 ; is < (Int_t)SLICES_MFADC; is++ ) {

        if ( sig[ip][is] > 0. ) {
          printf (" %4.1f/", sig[ip][is] ) ;
        }
        else {
          printf ("----/" ) ;
        }
      }
      
      printf ("\n"); 

    }
  }
  
} 

void MFadc::Scan(Float_t time) {
  
  //
  //    first of all we subtract from the time a offset (8 ns) 
  // 
  
  Float_t t ; 

  (0 > time - TIME_BEFORE_TRIGGER)? t=fadc_time_offset: t=(time-TIME_BEFORE_TRIGGER+fadc_time_offset) ; // to show also the start of the pulse before the trigger time

  if ( t < 0. ) {
    cout << " WARNING!! FROM MFADC::SCAN(t) " << endl ; 
    exit (776) ;  
  }

  //
  //  calculate the first slice to write out
  // 
  
  Int_t  iFirstSlice ; 

  iFirstSlice = (Int_t) ( t /  WIDTH_FADC_TIMESLICE ) ; 

  for ( Int_t ip=0; ip<numpix; ip++ ) {
    
    if ( used[ip] == kTRUE ) {

      printf ("Pid %3d",  ip ) ; 

      for ( Int_t is=iFirstSlice ; is < (iFirstSlice+15); is++ ) {
        printf (" %5.2f /", sig[ip][is] ) ; 
      }
      
      printf ("\n"); 

    }
  }  
} 

void MFadc::GetResponse( Float_t *resp ) {
  // ============================================================
  //
  //    puts the standard response function into the array resp
  
  for ( Int_t i=0; i< RESPONSE_SLICES; i++ ) {

    resp[i] = sing_resp[i] ; 
  }
}

void MFadc::GetPedestals( Float_t *offset) {
  // ============================================================
  //
  //    puts the pedestal values into the array offset
  
  for ( Int_t i=0; i< numpix; i++ ) {

    offset[i] = pedestal[i] ; 
  }
}

//===========================================================================
//
// Next function generates one pure noise event for pixel "pix", then adds 
// up the readouts of a number n_slices of its FADC slices, this being the 
// return value.
//
Float_t MFadc::AddNoiseInSlices( Int_t pix, Int_t ishigh, Int_t n_slices) {

  Float_t sum=0;
  Float_t fvalue = 0.;
  UChar_t value=0;
  
  Float_t factor;
  UInt_t startslice;

  //
  // If we deal with low gain, we have to scale the values in sig[][] by
  // the gain ratio (high2low_gain), since "sig" contains here the noise 
  // produce before the receiver boards (for instance NSB noise)
  //
  factor=(ishigh?1.0:high2low_gain);

  //
  // Get at random a point in the FADC presimulated digital noise:
  //
  startslice=GenElec->Integer((Int_t) SLICES_MFADC*999);

  for ( Int_t is=0; is < n_slices ; is++ ) 
    {
        fvalue = pedestal[pix]+(sig[pix][is]-pedestal[pix])/factor;
        fvalue += digital_noise[startslice+is];

        fvalue = fvalue < 0? fvalue-0.5 : fvalue+0.5;

        value = fvalue < 0.? (UChar_t) 0 :
          (fvalue > 255.? 255 : (UChar_t) fvalue);


      // Add up slices:
      sum += value - pedestal[pix];
    }

  return sum;
}

//=======================================================================

void MFadc::TriggeredFadc(Float_t time) {
  
  //
  //  calculate the first slice to write out, according to trigger time: 
  // 
  
  Int_t iFirstSlice ; 
  Int_t i;

  //
  // We had 0.5 for the correct rounding:
  //
  iFirstSlice = (Int_t) ( 0.5 + time /  WIDTH_FADC_TIMESLICE ) ; 


  for ( Int_t ip=0; ip<numpix; ip++ )
    {

      if ( used[ip] == kFALSE)
        // Pixels with no C-photons, in the case that camera is being run with
        // no noise (nor NSB neither electronic). We then set the mean pedestal as
        // signal, since when analyzing the camera output file, MARS will subtract 
        // it anyway!
        {
          for ( Int_t i=0 ; i < FADC_SLICES ; i++ ) 
            {
              output[ip][i]= pedestal[ip];
              output_lowgain[ip][i]= pedestal[ip];
            }
          continue;
        }

      i=0;
      for ( Int_t is=iFirstSlice ; is < (iFirstSlice+FADC_SLICES) ; is++ ) 
        {
          if (is < (Int_t)SLICES_MFADC)
            {
              output[ip][i] = sig[ip][is];

              // Low gain is scaled down by the factor high2low_gain:
              output_lowgain[ip][i]= pedestal[ip] + (sig[ip][is]-pedestal[ip])/high2low_gain;
            }
          else // We are beyond the simulated signal history in sig[][]! Put just mean pedestal!
            {
              output[ip][i] = pedestal[ip];
              output_lowgain[ip][i]= pedestal[ip];
            }
          i++;
        }
    }
}


void MFadc::ShowSignal (MMcEvt *McEvt, Float_t trigTime) { 
  // ============================================================
  //
  //  This method is used to book the histogram to show the signal in 
  //  a special gui frame (class MGTriggerSignal). After the look onto the
  //  signals for a better understanding of the things we will expect 
  //  the gui frame and all histogramms will be destroyed.   
  //
  
  //
  //  first of all create a list of the histograms to show
  //
  //  take only that one with a entry

  TH1F *hist ; 
  Char_t dumm[10]; 
  Char_t name[256]; 
  
  TObjArray  *AList ;
  AList = new TObjArray(10) ; 

  // the list of analog signal histograms
  // at the beginning we initalise 10 elements
  // but this array expand automatically if neccessay
  
  Int_t ic = 0 ; 
  for ( Int_t i=0 ; i < numpix; i++  ) {
    if ( used [i] == TRUE ) {

      sprintf (dumm, "FADC_%d", i ) ; 
      sprintf (name, "fadc signal %d", i ) ; 
      
      hist = new TH1F(dumm, name, (Int_t)SLICES_MFADC, fadc_time_offset, TOTAL_TRIGGER_TIME+fadc_time_offset); 
      //
      //  fill the histogram
      //
      
      for (Int_t ibin=1; ibin <=(Int_t)SLICES_MFADC; ibin++) {
        hist->SetBinContent (ibin, sig[i][ibin-1]) ;
      }

      //      hist->SetMaximum( 5.);
      //      hist->SetMinimum(-10.);
      hist->SetStats(kFALSE); 
  
      //      hist->SetAxisRange(0., 80. ) ; 
      
      AList->Add(hist) ; 
      
      ic++ ; 
    }
  }  

  //
  //   create the Gui Tool
  //
  //
  
  new MGFadcSignal(McEvt,
                   AList,
                   trigTime, 
                   gClient->GetRoot(), 
                   gClient->GetRoot(), 
                   400, 400 ) ; 
   
  //
  //   delete the List of histogramms
  //
  AList->Delete() ; 
  
  delete AList ; 
}

UChar_t MFadc::GetFadcSignal(Int_t pixel, Int_t slice){

  //  It returns the analog signal for a given pixel and a given FADC
  //  time slice which would be read.

  //  Since May 1 2004, we do the rounding and the truncation to the range 
  //  0-255 counts here. (A. Moralejo)

  Float_t out = output[pixel][slice] > 0. ? 
    output[pixel][slice]+0.5 : output[pixel][slice]-0.5; 
  // (add or subtract 0.5 for correct rounding)

  return (out < 0.? (UChar_t) 0 :
          (out > 255.? (UChar_t) 255 : 
           (UChar_t) out));
}

 
UChar_t MFadc::GetFadcLowGainSignal(Int_t pixel, Int_t slice){
 
   //  It returns the analog signal for a given pixel and a given FADC
   //  time slice which would be read. Same comment as above.
 
  Float_t outlow = output_lowgain[pixel][slice] > 0. ? 
    output_lowgain[pixel][slice]+0.5 : 
    output_lowgain[pixel][slice]-0.5; 
  // (add or subtract 0.5 for correct rounding)

  return (outlow < 0.? (UChar_t) 0 :
          (outlow > 255.? (UChar_t) 255 : 
           (UChar_t) outlow));
}