////////////////////////////////////////////////////////////////
//
//  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, Float_t fadc_slices_per_ns,
	     Int_t fadc_slices_written) {
  //
  //  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;
  fFadcSlicesPerNanosec = fadc_slices_per_ns;
  fFadcSlices = fadc_slices_written;

  fSlices_mFadc = (Int_t)(TOTAL_TRIGGER_TIME*fFadcSlicesPerNanosec);

  for (Int_t i = 0; i < CAMERA_PIXELS; i++)
    sig[i] = new Float_t[fSlices_mFadc];

  noise = new Float_t[fSlices_mFadc*1001];
  noise_outer = new Float_t[fSlices_mFadc*1001];
  digital_noise = new Float_t[fSlices_mFadc*1001];

  for (Int_t i = 0; i < CAMERA_PIXELS; i++)
    {
      output[i] = new Float_t[fFadcSlices];
      output_lowgain[i] = new Float_t[fFadcSlices];
    }

  cout<< "[MFadc]  Setting up the MFadc with this values "<< endl ; 
  cout<< "[MFadc]  FADC sampling frequency: " << fFadcSlicesPerNanosec << " GHz" << 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
  // 

  //
  // First select number of bins for the histogram which will contain the single 
  // photoelectron response of the FADC. The width of these bins is smaller than that 
  // of the real FADC slices by a factor SUBBINS (see MFadcDefine.h):
  //
  if (shape_resp == 1)
    fResponseSlicesFadc = (Int_t)(50.*fFadcSlicesPerNanosec*SUBBINS); 
  // 50 ns range

  else
    fResponseSlicesFadc = (Int_t)(7*fwhm_resp/2.35*fFadcSlicesPerNanosec*SUBBINS); 
  // 7 sigma range

  sing_resp = new Float_t[fResponseSlicesFadc];
  sing_resp_outer = new Float_t[fResponseSlicesFadc];

  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  = 1. / fFadcSlicesPerNanosec / 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 < fResponseSlicesFadc ; i++ ) 
      {  
	x = i * dX + dX2 ; 
      
	sing_resp[i] = (Float_t)(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 will set the peak of the pulse at x ~ 3*3.3 = 10 ns
            // 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;

    // Now define the time before trigger to read FADC signal when it
    // has to be written. Here FADC_SLICES_PER_NSEC (=0.3) is the value
    // for the 300 MHz MAGIC FADCs and must NOT be changed, even if you
    // use a faster sampling in the simulation (through the input card 
    // command "fadc_GHz"), because this is just a conversion of units. The
    // parameters of the "pulpo" pulse shape were obtained with the 300 MHz
    // FADC and so we convert the time parameter to units of 3.3 ns slices 
    // just to use the provided parametrization, and no matter what sampling 
    // frequency we are simulating!

    fadc_time_offset = trigger_delay - p3 / FADC_SLICES_PER_NSEC; // ns

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

	// x has to be converted from ns to units FADC slices of the default 
	// FADC of 300 MHz (these are just units, and must be these even if you
	// are using another sampling frequency!):
	//
	zed_slices = x * FADC_SLICES_PER_NSEC - p3;
	d=(zed_slices>0)?0.5:-0.5;

	sing_resp[i] =  (Float_t) (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 < fResponseSlicesFadc ; 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] = (Float_t) (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*3.3 = 10 nanosec
            // 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;

    // Now define the time before trigger to read FADC signal when it
    // has to be written. Here FADC_SLICES_PER_NSEC (=0.3) is the value
    // for the 300 MHz MAGIC FADCs and must NOT be changed, even if you
    // use a faster sampling in the simulation (through the input card 
    // command "fadc_GHz"), because this is just a conversion of units. The
    // parameters of the "pulpo" pulse shape were obtained with the 300 MHz
    // FADC and so we convert the time parameter to units of 3.3 ns slices 
    // just to use the provided parametrization, and no matter what sampling 
    // frequency we are simulating!

    fadc_time_offset = trigger_delay - p3 / FADC_SLICES_PER_NSEC; // ns

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

	// x has to be converted from ns to units FADC slices of the default 
	// FADC of 300 MHz (these are just units, and must be these even if you
	// are using another sampling frequency!):
	//
	zed_slices = x * FADC_SLICES_PER_NSEC - p3;
	d=(zed_slices>0)?0.5:-0.5;

	sing_resp_outer[i] = (Float_t) (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< fResponseSlicesFadc ; 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));

    for (Int_t i = 0; i < CAMERA_PIXELS; i++)
      {
	memset(output[i], 0, fFadcSlices*sizeof(Float_t));
	memset(output_lowgain[i], 0, fFadcSlices*sizeof(Float_t));
      }

    // 
    // Added 15 01 2004, AM:
    //
    for (Int_t i = 0; i < CAMERA_PIXELS; i++)
      memset(sig[i], 0, (Int_t)(fSlices_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
  //
  // Parameters are the number of the pixel and the time-difference to the
  // first photon.
  //
  //
  // AM, Jan 2004: Replaced former FADC simulation (integration of signal)
  // with a more realistic one (measuring signal height at discrete points).
  //


  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 pixel
  // 
  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) fSlices_mFadc; i++ ) 
	sig[iPix][i] = 0.; 
    }

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

  if ( time < TOTAL_TRIGGER_TIME+fadc_time_offset ) { 
    //
    // Convert time into units of the width of the analog 
    // signal histogram, sing_resp:
    //
    ichan = (Int_t) ( time * fFadcSlicesPerNanosec * SUBBINS); 

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

    // We want to put the single phe response given by sing_resp into the
    // array sig[][], but only one of each SUBBINS bins, since the binning 
    // of sing_resp is finer than that of sig[][]. We want that the start of
    // sing_resp coincides with the time "time" with respect to the begining
    // of sig[][]

    // 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;    //
    //
    // first_i is the first bin of sing_resp which matches the center of one
    // bin of sig[][]
    //

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

	//
	// fSlices_mFadc is by default 48. sig[][] is not the true FADC, which
	// is filled (from sig[][]) in MFadc::TriggeredFadc()
	//
	if ( (ichanfadc) < (Int_t) fSlices_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
  //
  // See explanations of the code in function Fill() above 
  //

  Int_t i, ichan, ichanfadc ; 
  
  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) fSlices_mFadc; i++)
	sig[iPix][i] = 0.;
    }


  if ( time < TOTAL_TRIGGER_TIME+fadc_time_offset ) { 

    ichan = (Int_t) ( time * fFadcSlicesPerNanosec * SUBBINS); 

    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)fResponseSlicesFadc; i += (Int_t)SUBBINS)
      {
	ichanfadc = (Int_t) ((ichan+i)/SUBBINS); 

	if ( ichanfadc < 0 )
	  continue;

	if ( (ichanfadc) < (Int_t)fSlices_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) { 
  
  //
  // 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)fSlices_mFadc; i++ ) {
      sig[iPix][i] = 0. ; 
    }
  }
  for ( i = 0 ; i<(Int_t)fSlices_mFadc; i++ ) {
    sig[iPix][i] = resp[i] ; 
  }

}

void MFadc::AddSignal( Int_t iPix, Float_t *resp) { 
  
  //
  // 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)fSlices_mFadc; i++ ) {
      sig[iPix][i] = 0. ; 
    }
  }
  for ( i = 0 ; i<(Int_t)fSlices_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) fSlices_mFadc;i++){
      baseline+=sig[j][i];
    }
    baseline=baseline/fSlices_mFadc;
    for(i=0;i<(Int_t) fSlices_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)fSlices_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) fSlices_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) fSlices_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) fSlices_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) fSlices_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 (fSlices_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)fSlices_mFadc)*1000);

    if ( used[i] == FALSE )
    {
	used [i] = TRUE ; 
	if (i < fInnerPixelsNum)
	    memcpy( (Float_t*)&sig[i][0],
		    (Float_t*)&noise[startslice], 
		    ((Int_t) fSlices_mFadc)*sizeof(Float_t));
	else
	    memcpy( (Float_t*)&sig[i][0],
		    (Float_t*)&noise_outer[startslice], 
		    ((Int_t) fSlices_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)fSlices_mFadc ; is++ ) 
		sig[i][is] += noise[startslice+is];
	else
	    for ( Int_t is=0 ; is< (Int_t)fSlices_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(fSlices_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) fSlices_mFadc*999);
      //      
      //  Then the noise is introduced for each time slice
      //
      for ( Int_t is = 0 ; is < fFadcSlices; is++ ) 
	{ 
	  output[i][is] += digital_noise[startslice+is];
	  output_lowgain[i][is] += digital_noise[startslice+fFadcSlices+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)fSlices_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 * fFadcSlicesPerNanosec ) ; 

  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< fResponseSlicesFadc; 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) fSlices_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 * fFadcSlicesPerNanosec ) ; 

  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 < fFadcSlices ; i++ ) 
	    {
	      output[ip][i]= pedestal[ip];
	      output_lowgain[ip][i]= pedestal[ip];
	    }
	  continue;
	}

      i=0;
      for ( Int_t is = iFirstSlice; is < (iFirstSlice+fFadcSlices); is++ ) 
	{
	  if (is < (Int_t)fSlices_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)fSlices_mFadc, fadc_time_offset, TOTAL_TRIGGER_TIME+fadc_time_offset); 
      //
      //  fill the histogram
      //
      
      for (Int_t ibin = 1; ibin <= (Int_t)fSlices_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));
}



