source: trunk/MagicSoft/Simulation/Detector/include-MFadc/MFadc.hxx@ 5079

#ifndef __MFadc__
#define __MFadc__
//
//     class MFadc
//
//     implemented by Harald Kornmayer
//
//     This is a class to simulate the FADC. 
//     It assumes a special response of the PMT for one single Photo-electron. 
//     
//
//
#include <stream.h>
#include <math.h>

#include "TObject.h"
#include "TRandom.h"

#include "Mdefine.h" 

#include "MTriggerDefine.h"
#include "MFadcDefine.h"

class MMcEvt  ; 

//==========
//  MFadc 
//
//  The simulation of the Flash ADC system for the MAGIC teleskop is done with
//  this class. 
//  So all methods concerning the FADC System should be done inside this
//  class. 
//
//  The Idea is to (in)put the data of the photo electrons into the class and
//  generate the response (output) of the FADC to that input. Response means 
//  in this sense the ADC values of the different time slices for all pixels
//
//  The pixelisation is done by the camera program of Jose Carlos. 
//
//  This class is closly connected to the MTrigger classs. So some of the
//  values defined in MTriggerDefine.h are also used by this class. 
//
//  But a lot of other stuff is defined in MFadcDefine.h. 
//
//


class MFadc {
 private:
  Int_t numpix;
  Int_t fInnerPixelsNum; // number of inner (small) pixels.
  //
  //    then for all pixels the shape of all the analog signals 
  //
  Bool_t   used[CAMERA_PIXELS] ;  //  a boolean to indicated if the pixels is used in this event
  Float_t  pedestal[CAMERA_PIXELS] ;  //  Pedestal of FADCs

  Float_t  sig[CAMERA_PIXELS][(Int_t) SLICES_MFADC] ; //  the analog signal for pixels, in bins of width
                                                      //  equal to the FADC slice: 50/15 ns, but with a
                                                      //  total of SLICES_MFADC (=48 now) bins.
  Float_t noise[((Int_t) SLICES_MFADC)*1001];
  Float_t noise_outer[((Int_t) SLICES_MFADC)*1001];
  Int_t digital_noise[((Int_t) SLICES_MFADC)*1001];

  Float_t  output[CAMERA_PIXELS][FADC_SLICES];  //  the analog signal for pixels that is read after a trigger 
                                                //  occurs (high gain). Only 15 (=FADC_SLICES) bins

  Float_t  output_lowgain[CAMERA_PIXELS][FADC_SLICES]; //  analog signal, low gain.

  Float_t high2low_gain;
  //
  //    first the data for the response function
  //
  Int_t shape_resp ;                      // index shape of the phe_response function
                                          // = 0 --> Gaussian
                                          // = 1 --> Pulpo set-up
  Float_t fwhm_resp ;                      // fwhm of the phe_response function (in ns)
  Float_t integ_resp ;                      // area below curve of the phe_response function (in counts * ns)
  Float_t sing_resp[ RESPONSE_SLICES_MFADC ] ;   // the shape of the phe_response function 

  //
  //    We may end up with a different reponse for the outer pixels
  //
  Int_t shape_resp_outer ;                      // index shape of the phe_response function
                                          // = 0 --> Gaussian
                                          // = 1 --> Pulpo set-up
  Float_t fwhm_resp_outer ;                      // fwhm of the phe_response function (in ns)
  Float_t integ_resp_outer ;                      // area below curve of the phe_response function (in counts * ns)
  Float_t sing_resp_outer[ RESPONSE_SLICES_MFADC ] ;   // the shape of the phe_response function 
  //
  //   RandomGenerator for the Electonic Noise
  //

  TRandom  *GenElec ; 

  Float_t fadc_time_offset; // Time offset to adjust the delay between trigger
                            // and the peak position in the FADC of the signal
                            // in the trigger pixels.


public:

  MFadc(Int_t pix=577,
        Int_t shape=0,
        Float_t ampl=MFADC_RESPONSE_INTEGRAL, 
        Float_t fwhm=MFADC_RESPONSE_FWHM,
        Int_t shapeout=0,
        Float_t amplout=MFADC_RESPONSE_INTEGRAL, 
        Float_t fwhmout=MFADC_RESPONSE_FWHM,
        Float_t trig_delay=0.) ;
  
  void SetSeed(UInt_t seed)  {GenElec->SetSeed(seed);}

  void Reset() ; 

  void Fill( Int_t, Float_t, Float_t, Int_t  ) ;  

  void Fill( Int_t, Float_t, Float_t  ) ;  

  void FillOuter( Int_t, Float_t, Float_t  ) ;  

  void Set( Int_t iPix, Float_t res[(Int_t) SLICES_MFADC]);

  void AddSignal( Int_t iPix, Float_t res[(Int_t) SLICES_MFADC]);

  void SetPedestals( Int_t ped);

  void SetPedestals( Float_t *ped);

  void SetShape( Int_t inner, Int_t outer){
    shape_resp=inner;
    shape_resp_outer=outer;
  }

  void SetFwhm( Float_t fwhm){
    fwhm_resp=fwhm;
  }

  void SetInteg( Float_t x){
    integ_resp=x;
  }

  void SetFwhmOuter( Float_t fwhm){
    fwhm_resp_outer=fwhm;
  }

  void SetIntegOuter( Float_t x){
    integ_resp_outer=x;
  }

  void Baseline();

  void Pedestals();

  void Offset( Float_t, Int_t );

  void SetElecNoise(Float_t value1=2.0, Float_t value2=2.0, UInt_t ninpix=CAMERA_PIXELS);

  void ElecNoise(); 

  void SetDigitalNoise(Float_t value=2.0);

  void DigitalNoise() ; 

  void Scan() ; 

  void Scan(Float_t time) ;

  void GetResponse( Float_t *resp ) ; 

  void GetPedestals( Float_t *offset);

  Float_t GetPedestalNoise (Int_t pix, Int_t ishigh);

  Float_t AddNoiseInSlices( Int_t pix, Int_t ishigh, Int_t n_slices);

  void TriggeredFadc(Float_t time);

  void ShowSignal ( MMcEvt *McEvt , Float_t ) ; 

  UChar_t GetFadcSignal(Int_t pixel, Int_t slice);

  UChar_t GetFadcLowGainSignal(Int_t pixel, Int_t slice);

  void SetHigh2LowGain(Float_t h2l) {high2low_gain=h2l;}

  Float_t GetShape() {
    return shape_resp;
  }

  Float_t GetIntegral() {
    return integ_resp ; 
  }

  Float_t GetFwhm() {
    return fwhm_resp ; 
  }

  Float_t GetIntegralOuter() {
    return integ_resp_outer ; 
  }

  Float_t GetFwhmOuter() {
    return fwhm_resp_outer ; 
  }

  Bool_t IsPixelUsed(UInt_t p){
    return used[p];
  }
  
} ; 


#endif