Final granularity of digitization implemented
authorschutz <schutz@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 27 Sep 2001 14:39:05 +0000 (14:39 +0000)
committerschutz <schutz@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 27 Sep 2001 14:39:05 +0000 (14:39 +0000)
PHOS/AliPHOSClusterizerv1.cxx
PHOS/AliPHOSClusterizerv1.h
PHOS/AliPHOSDigitizer.cxx
PHOS/AliPHOSDigitizer.h
PHOS/AliPHOSSDigitizer.h

index aeaa9cb..9e12dde 100644 (file)
@@ -149,6 +149,14 @@ AliPHOSClusterizerv1::AliPHOSClusterizerv1(const char* headerFile,const char* na
 {
 }
 //____________________________________________________________________________
+Float_t  AliPHOSClusterizerv1::Calibrate(Int_t amp, Int_t absId) const
+{
+  if(absId <= fEmcCrystals) //calibrate as EMC 
+    return fADCpedestalEmc + amp*fADCchanelEmc ;       
+  else //Digitize as CPV
+    return fADCpedestalCpv+ amp*fADCchanelCpv ;       
+}
+//____________________________________________________________________________
 void AliPHOSClusterizerv1::Exec(Option_t * option)
 {
   // Steering method
@@ -196,10 +204,7 @@ void AliPHOSClusterizerv1::Exec(Option_t * option)
 
   for(ievent = 0; ievent < nevents; ievent++){
 
-
-    fPedestal = gime->Digitizer(branchname)->GetPedestal() ;
-    fSlope    = gime->Digitizer(branchname)->GetSlope() ;
-
+    if(ievent == 0) GetCalibrationParameters() ;
 
     fNumberOfEmcClusters  = 0 ;
     fNumberOfCpvClusters  = 0 ;
@@ -321,6 +326,20 @@ Bool_t AliPHOSClusterizerv1::FindFit(AliPHOSEmcRecPoint * emcRP, int * maxAt, Fl
 }
 
 //____________________________________________________________________________
+void AliPHOSClusterizerv1::GetCalibrationParameters() 
+{
+  AliPHOSGetter * gime = AliPHOSGetter::GetInstance() ;
+  TString branchname = GetName() ;
+  branchname.Remove(branchname.Index(Version())-1) ;
+  AliPHOSDigitizer * dig = gime->Digitizer(branchname) ;
+  fADCchanelEmc   = dig->GetEMCchannel() ;
+  fADCpedestalEmc = dig->GetEMCpedestal();
+
+  fADCchanelCpv   = dig->GetCPVchannel() ;
+  fADCpedestalCpv = dig->GetCPVpedestal() ; 
+
+}
+//____________________________________________________________________________
 void AliPHOSClusterizerv1::Init()
 {
   // Make all memory allocations which can not be done in default constructor.
@@ -338,6 +357,9 @@ void AliPHOSClusterizerv1::Init()
     return ;
   } 
     
+  const AliPHOSGeometry * geom = gime->PHOSGeometry() ;
+  fEmcCrystals = geom->GetNModules() *  geom->GetNCristalsInModule() ;
+
   if(!gMinuit) 
     gMinuit = new TMinuit(100) ;
 
@@ -559,8 +581,8 @@ void AliPHOSClusterizerv1::MakeClusters()
     TArrayI clusterdigitslist(1500) ;   
     Int_t index ;
 
-    if (( IsInEmc (digit) && Calibrate(digit->GetAmp()) > fEmcClusteringThreshold  ) || 
-        ( IsInCpv (digit) && Calibrate(digit->GetAmp()) > fCpvClusteringThreshold  ) ) {
+    if (( IsInEmc (digit) && Calibrate(digit->GetAmp(),digit->GetId()) > fEmcClusteringThreshold  ) || 
+        ( IsInCpv (digit) && Calibrate(digit->GetAmp(),digit->GetId()) > fCpvClusteringThreshold  ) ) {
       
       Int_t iDigitInCluster = 0 ; 
       
@@ -572,7 +594,7 @@ void AliPHOSClusterizerv1::MakeClusters()
        emcRecPoints->AddAt(new  AliPHOSEmcRecPoint(), fNumberOfEmcClusters) ;
        clu = (AliPHOSEmcRecPoint *) emcRecPoints->At(fNumberOfEmcClusters) ; 
        fNumberOfEmcClusters++ ; 
-       clu->AddDigit(*digit, Calibrate(digit->GetAmp())) ; 
+       clu->AddDigit(*digit, Calibrate(digit->GetAmp(),digit->GetId())) ; 
        clusterdigitslist[iDigitInCluster] = digit->GetIndexInList() ;  
        iDigitInCluster++ ; 
        digitsC->Remove(digit) ; 
@@ -587,7 +609,7 @@ void AliPHOSClusterizerv1::MakeClusters()
 
        clu =  (AliPHOSCpvRecPoint *) cpvRecPoints->At(fNumberOfCpvClusters)  ;  
        fNumberOfCpvClusters++ ; 
-       clu->AddDigit(*digit, Calibrate(digit->GetAmp()) ) ;    
+       clu->AddDigit(*digit, Calibrate(digit->GetAmp(),digit->GetId()) ) ;     
        clusterdigitslist[iDigitInCluster] = digit->GetIndexInList()  ; 
        iDigitInCluster++ ; 
        digitsC->Remove(digit) ; 
@@ -620,7 +642,7 @@ void AliPHOSClusterizerv1::MakeClusters()
           case 0 :   // not a neighbour
            break ;
          case 1 :   // are neighbours 
-           clu->AddDigit(*digitN, Calibrate( digitN->GetAmp() ) ) ;
+           clu->AddDigit(*digitN, Calibrate( digitN->GetAmp(), digitN->GetId() ) ) ;
            clusterdigitslist[iDigitInCluster] = digitN->GetIndexInList() ; 
            iDigitInCluster++ ; 
            digitsC->Remove(digitN) ;
index a51f54d..d20037b 100644 (file)
@@ -37,6 +37,9 @@ public:
   
   Int_t           AreNeighbours(AliPHOSDigit * d1, AliPHOSDigit * d2)const ; 
                                // Checks if digits are in neighbour cells 
+
+  virtual Float_t Calibrate(Int_t amp, Int_t absId)const ;  // Tranforms Amp to energy 
+
   virtual void    GetNumberOfClustersFound(int * numb )const{  numb[0] = fNumberOfEmcClusters ; 
                                                                numb[1] = fNumberOfCpvClusters ; }
 
@@ -74,7 +77,8 @@ public:
   
 private:
 
-  virtual Float_t Calibrate(Int_t amp)const {  return (amp-fPedestal)/fSlope ;}  // Tranforms Amp to energy 
+  void    GetCalibrationParameters(void) ;
+  
   Bool_t  FindFit(AliPHOSEmcRecPoint * emcRP, int * MaxAt, Float_t * maxAtEnergy, 
                  Int_t NPar, Float_t * FitParametres) const; //Used in UnfoldClusters, calls TMinuit
   void Init() ;
@@ -95,13 +99,17 @@ private:
   TString fDigitsBranchTitle ;       // name of the file, where digits branch is stored
   TString fRecPointsBranchTitle ;    // name of the file, where RecPoints branchs are stored
 
+  Int_t   fEmcCrystals ;             // number of EMC cristalls in PHOS
+
   Bool_t  fToUnfold ;                // To perform unfolding 
 
   Int_t   fNumberOfEmcClusters ;     // number of EMC clusters found 
   Int_t   fNumberOfCpvClusters ;     // number of CPV clusters found
  
-  Float_t fPedestal ;                // Calibration parameters 
-  Float_t fSlope ;                   // read from Digitizer
+  Float_t fADCchanelEmc ;           // width of one ADC channel in GeV
+  Float_t fADCpedestalEmc ;         //
+  Float_t fADCchanelCpv ;           // width of one ADC channel in CPV 'popugais'
+  Float_t fADCpedestalCpv ;         // 
 
   Float_t fEmcClusteringThreshold ;  // minimum energy to include a EMC digit in a cluster
   Float_t fCpvClusteringThreshold ;  // minimum energy to include a CPV digit in a cluster
index 8dfe5ea..1054b83 100644 (file)
@@ -93,10 +93,16 @@ ClassImp(AliPHOSDigitizer)
   fTimeResolution     = 1.0e-9 ;
   fTimeSignalLength   = 1.0e-9 ;
   fDigitsInRun  = 0 ; 
-  fPedestal = 0.;                // Calibration parameters 
-  fSlope = 10000000. ;
-  fTimeThreshold = 0.001*fSlope ; //Means 1 MeV in terms of SDigits amplitude
-  fARD = 0 ;                     // We work in the standalong mode
+  fADCchanelEmc = 0.0015;        // width of one ADC channel in GeV
+  fADCpedestalEmc = 0.005 ;      //
+  fNADCemc = (Int_t) TMath::Power(2,16) ;  // number of channels in EMC ADC
+
+  fADCchanelCpv = 0.0012 ;          // width of one ADC channel in CPV 'popugais'
+  fADCpedestalCpv = 0.012 ;         // 
+  fNADCcpv = (Int_t) TMath::Power(2,12);      // number of channels in CPV ADC
+
+  fTimeThreshold = 0.001*10000000 ; //Means 1 MeV in terms of SDigits amplitude
+  fARD = 0 ;                        // We work in the standalong mode
 }
 
 //____________________________________________________________________________ 
@@ -105,17 +111,7 @@ AliPHOSDigitizer::AliPHOSDigitizer(const char *headerFile,const char * name)
   // ctor
   SetName(name) ;
   SetTitle(headerFile) ;
-  fPinNoise           = 0.01 ;
-  fEMCDigitThreshold  = 0.01 ;
-  fCPVNoise           = 0.01;
-  fCPVDigitThreshold  = 0.09 ;
-  fDigitsInRun  = 0 ; 
-  fPedestal = 0.;                // Calibration parameters 
-  fSlope = 10000000. ;
-  fTimeSignalLength   = 1.0e-9 ;
-  fTimeThreshold = 0.001*fSlope ; //Means 1 MeV in terms of SDigits amplitude
   fARD = 0 ;                     // We work in the standalong mode
-
   Init() ;
   
 }
@@ -127,15 +123,6 @@ AliPHOSDigitizer::AliPHOSDigitizer(AliRunDigitizer * ard)
   fARD = ard ;
   SetName("Default");
   SetTitle("aliroot") ;
-
-  fPinNoise           = 0.01 ;
-  fEMCDigitThreshold  = 0.01 ;
-  fCPVNoise           = 0.01;
-  fCPVDigitThreshold  = 0.09 ;
-  fDigitsInRun  = 0 ; 
-  fPedestal = 0.;                // Calibration parameters 
-  fSlope = 10000000. ;
-
   Init() ;
   
 }
@@ -164,6 +151,7 @@ void AliPHOSDigitizer::Digitize(const Int_t event)
 
   AliPHOSGetter * gime = AliPHOSGetter::GetInstance() ; 
   TClonesArray * digits = gime->Digits(GetName()) ; 
+  AliPHOSSDigitizer * sdiz = gime->SDigitizer(GetName()) ; 
 
   digits->Clear() ;
 
@@ -337,14 +325,29 @@ void AliPHOSDigitizer::Digitize(const Int_t event)
   Int_t ndigits = digits->GetEntriesFast() ;
   digits->Expand(ndigits) ;
 
-  //Set indexes in list of digits
+  //Set indexes in list of digits and make true digitization of the energy
   for (i = 0 ; i < ndigits ; i++) { 
     AliPHOSDigit * digit = (AliPHOSDigit *) digits->At(i) ; 
     digit->SetIndexInList(i) ;     
+    Float_t energy = sdiz->Calibrate(digit->GetAmp()) ;
+    digit->SetAmp(DigitizeEnergy(energy,digit->GetId()) ) ;
   }
 
 }
-
+//____________________________________________________________________________
+Int_t AliPHOSDigitizer::DigitizeEnergy(Float_t energy, Int_t absId)
+{
+  Int_t chanel ;
+  if(absId <= fEmcCrystals){ //digitize as EMC 
+    chanel = (Int_t) TMath::Ceil((energy - fADCpedestalEmc)/fADCchanelEmc) ;       
+    if(chanel > fNADCemc ) chanel =  fNADCemc ;
+  }
+  else{ //Digitize as CPV
+    chanel = (Int_t) TMath::Ceil((energy - fADCpedestalCpv)/fADCchanelCpv) ;       
+    if(chanel > fNADCcpv ) chanel =  fNADCcpv ;
+  }
+  return chanel ;
+}
 //____________________________________________________________________________
 void AliPHOSDigitizer::Exec(Option_t *option) 
 { 
@@ -466,8 +469,26 @@ Float_t AliPHOSDigitizer::FrontEdgeTime(TClonesArray * ticks)
 //____________________________________________________________________________ 
 Bool_t AliPHOSDigitizer::Init()
 {
+  fPinNoise           = 0.01 ;
+  fEMCDigitThreshold  = 0.01 ;
+  fCPVNoise           = 0.01;
+  fCPVDigitThreshold  = 0.09 ;
+  fTimeResolution     = 1.0e-9 ;
+  fTimeSignalLength   = 1.0e-9 ;
+  fDigitsInRun  = 0 ; 
+  fADCchanelEmc = 0.0015;        // width of one ADC channel in GeV
+  fADCpedestalEmc = 0.005 ;      //
+  fNADCemc = (Int_t) TMath::Power(2,16) ;  // number of channels in EMC ADC
+
+  fADCchanelCpv = 0.0012 ;          // width of one ADC channel in CPV 'popugais'
+  fADCpedestalCpv = 0.012 ;         // 
+  fNADCcpv = (Int_t) TMath::Power(2,12);      // number of channels in CPV ADC
+
+  fTimeThreshold = 0.001*10000000 ; //Means 1 MeV in terms of SDigits amplitude
+
   // Makes all memory allocations
   // Adds Digitizer task to the folder of PHOS tasks
+
    //============================================================= YS
   //  The initialisation is now done by AliPHOSGetter
     
@@ -482,6 +503,9 @@ Bool_t AliPHOSDigitizer::Init()
     cerr << "ERROR: AliPHOSDigitizer::Init -> Could not obtain the Getter object !" << endl ; 
     return kFALSE;
   } 
+  
+  const AliPHOSGeometry * geom = gime->PHOSGeometry() ;
+  fEmcCrystals = geom->GetNModules() *  geom->GetNCristalsInModule() ;
      
   // create a folder on the white board //YSAlice/WhiteBoard/Digits/PHOS/headerFile/digitsTitle
   gime->PostDigits(GetName() ) ;   
index 68eb249..9703f31 100644 (file)
@@ -36,26 +36,41 @@ public:
   virtual ~AliPHOSDigitizer() ;       
 
   void    Digitize(const Int_t event) ;            // Make Digits from SDigits 
-  void    Exec(Option_t *option);                // Supervising method
+  void    Exec(Option_t *option);                  // Supervising method
 
+  //CPV parameters
   const Float_t GetCPVNoise()     const { return fCPVNoise ;}
   const Float_t GetCPVThreshold() const { return fCPVDigitThreshold ;}
-  const Int_t   GetDigitsInRun()  const { return fDigitsInRun ;}  
+  const Float_t GetCPVchannel()   const { return fADCchanelCpv; }
+  const Float_t GetCPVpedestal()  const { return fADCpedestalCpv; }
+
+  void    SetCPVNoise(Float_t CPVNoise)          {fCPVNoise = CPVNoise;}
+  void    SetCPVThreshold(Float_t CPVThreshold)  {fCPVDigitThreshold= CPVThreshold;}
+  void    SetNCPVchannels(Int_t n)     { fNADCcpv = n; }
+  void    SetCPVchannel(Float_t width) { fADCchanelCpv = width; }
+  void    SetCPVpedestal(Float_t ped)  { fADCpedestalCpv = ped; }
+
+
+  //EMC parameters
   const Float_t GetEMCThreshold() const { return fEMCDigitThreshold;}
-  const Float_t GetPedestal()     const { return fPedestal; }
+  const Float_t GetEMCchannel()   const { return fADCchanelEmc; }
+  const Float_t GetEMCpedestal()  const { return fADCpedestalEmc; }  
   const Float_t GetPinNoise()     const { return fPinNoise;}
-  const Float_t GetSlope()        const { return fSlope; }
   const Float_t GetTimeResolution() const { return fTimeResolution ; }
 
+  void   SetEMCThreshold(Float_t EMCThreshold)  {fEMCDigitThreshold = EMCThreshold;}
+  void   SetPinNoise(Float_t PinNoise )         {fPinNoise = PinNoise;}
+  void   SetNEMCchannels(Int_t n)      { fNADCemc = n; }
+  void   SetEMCchannel(Float_t width)  { fADCchanelEmc = width; }
+  void   SetEMCpedestal(Float_t ped)   { fADCpedestalEmc = ped ; }  
+
+  //General
+  const Int_t   GetDigitsInRun()  const { return fDigitsInRun ;}  
+
   void    MixWith(const char* HeaderFile) ; // Add another one file to mix
   void    Print(Option_t* option)const ;
   void    Reset() ;   //restarts starts event processing from 0 event(s)
 
-  void    SetCPVNoise(Float_t CPVNoise)          {fCPVNoise = CPVNoise;}
-  void    SetCPVThreshold(Float_t CPVThreshold)  {fCPVDigitThreshold= CPVThreshold;}
-  void    SetEMCThreshold(Float_t EMCThreshold)  {fEMCDigitThreshold = EMCThreshold;}
-  void    SetPinNoise(Float_t PinNoise )         {fPinNoise = PinNoise;}
-
   void    SetSDigitsBranch(const char* file) ;
 
   AliPHOSDigitizer & operator = (const AliPHOSDigitizer & rvalue)  {
@@ -65,35 +80,41 @@ public:
   }
 
 private:
+
   Bool_t  Init() ; 
   void    PrintDigits(Option_t * option) ;
   void    WriteDigits(Int_t evt) ;            // Writes Digits for particular event
   Float_t TimeOfNoise(void) ;                 // Calculate time signal generated by noise
-  Float_t FrontEdgeTime(TClonesArray * ticks) ; 
-  Int_t   DigitizeEnergy(Int_t amp, Int_t absId) ;
   //Calculate the time of crossing of the threshold by front edge
-private:
+  Float_t FrontEdgeTime(TClonesArray * ticks) ; 
+  //Calculate digitized signal with gived ADC parameters
+  Int_t   DigitizeEnergy(Float_t energy, Int_t absId) ;
 
-  Float_t fPedestal ;                // Calibration parameters read from SDigitizer  
-  Float_t fSlope ;                   // (nothing common with real digitization parameters)
+private:
 
   AliRunDigitizer * fARD ;          //! Pointer to the Digitization Manager class
+
   Int_t   fEmcCrystals ;            // Number of EMC crystalls in the given geometry
+
   Float_t fPinNoise ;               // Electronics noise in EMC
   Float_t fEMCDigitThreshold  ;     // Threshold for storing digits in EMC
+
   Float_t fCPVNoise ;               // Noise in CPV
   Float_t fCPVDigitThreshold  ;     // Threshold for storing digits in CPV
+
   Int_t fDigitsInRun ;              //! Total number of digits in one run
 
   Float_t fTimeResolution ;         // Time resolution of FEE electronics
-
   Float_t fTimeThreshold ;          // Threshold to start timing for given crystall
   Float_t fTimeSignalLength ;       // Length of the timing signal 
 
-  Int_t   fNADCbitsEmc ;
-  Float_t fADCpedestalEmc ;
-  Int_t   fNADCbitsCPV ;
-  Float_t fADCperestalCPV ;
+  Float_t fADCchanelEmc ;           // width of one ADC channel in GeV
+  Float_t fADCpedestalEmc ;         //
+  Int_t   fNADCemc ;                // number of channels in EMC ADC
+
+  Float_t fADCchanelCpv ;           // width of one ADC channel in CPV 'popugais'
+  Float_t fADCpedestalCpv ;         // 
+  Int_t   fNADCcpv ;                // number of channels in CPV ADC
 
 
   ClassDef(AliPHOSDigitizer,1)  // description 
index bbe56aa..77ab00f 100644 (file)
@@ -32,15 +32,11 @@ public:
 
   virtual void  Exec(Option_t *option); 
   
-  const Float_t  GetPedestalParameter()const {return fA;}
-  const Float_t  GetCalibrationParameter()const{return fB;}
   const char *   GetSDigitsBranch()const{return GetName();}  
   const Int_t    GetSDigitsInRun() const {return fSDigitsInRun ;}  
 
   virtual void Print(Option_t* option) const ;
 
-  void     SetPedestalParameter(Float_t A){fA = A ;}
-  void     SetSlopeParameter(Float_t B){fB = B ;}
   void     SetSDigitsBranch(const char * title ) ;
 
   void  UseHitsFrom(const char * filename) ;