Cell number replaced by PM number in digit Tree

diff --git a/VZERO/AliVZERO.cxx b/VZERO/AliVZERO.cxx
index a07bcf72057eddfed9365f4f8aecc3ab7347a6b9..105681d63cab91496125f39045ffb403083603f6 100755 (executable)
--- a/VZERO/AliVZERO.cxx
+++ b/VZERO/AliVZERO.cxx
@@ -281,16 +281,16 @@ void AliVZERO::Digits2Raw()
     if(fVerbose == 2) {ftxt.open("VZEROdigits.txt",ios::app);}
     for(Int_t k=0; k<ndig; k++){
         AliVZEROdigit* fVZERODigit = (AliVZEROdigit*) VZEROdigits->At(k);                      
-       Int_t ADC   = fVZERODigit->ADC();
-       Int_t cell  = fVZERODigit->CellNumber();
-       Int_t Time  = fVZERODigit->Time();
-        if(fVerbose == 1) { cout <<"DDL: "<<fileName<< "\tdigit number: "<< k<<"\tcell: "
-                           <<cell<<"\tADC: "<< ADC << "\tTime: "<< Time << endl;} 
+       Int_t ADC       = fVZERODigit->ADC();
+       Int_t PMNumber  = fVZERODigit->PMNumber();
+       Int_t Time      = fVZERODigit->Time();
+        if(fVerbose == 1) { cout <<"DDL: "<<fileName<< "\tdigit number: "<< k<<"\tPM number: "
+                           <<PMNumber<<"\tADC: "<< ADC << "\tTime: "<< Time << endl;} 
        if(fVerbose == 2) {
-           ftxt<<"DDL: "<<fileName<< "\tdigit number: "<< k<<"\tcell: "
-                          <<cell<<"\tADC: "<< ADC << endl;           
+           ftxt<<"DDL: "<<fileName<< "\tdigit number: "<< k<<"\tPM number: "
+                          <<PMNumber<<"\tADC: "<< ADC << "\tTime: "<< Time << endl;          
        }
-        buffer->WriteBinary(cell, ADC, Time);
+        buffer->WriteBinary(PMNumber, ADC, Time);
     }
   if(fVerbose==2) ftxt.close();
   }

diff --git a/VZERO/AliVZERODigitizer.cxx b/VZERO/AliVZERODigitizer.cxx
index 37d05a1f9442054a6b2e9808f153fd8abce533ec..67e8bbf311403794de2d4abfb9552feb11ab5980 100644 (file)
--- a/VZERO/AliVZERODigitizer.cxx
+++ b/VZERO/AliVZERODigitizer.cxx
@@ -102,8 +102,9 @@ void AliVZERODigitizer::Exec(Option_t* /*option*/)
 {   
   // Creates digits from hits
      
-  Int_t       adc[80];    // 48 values on V0C + 32 on V0A
-  Float_t    time[80], adc_gain[80];    
+  Int_t       map[80];    // 48 values on V0C + 32 on V0A
+  Int_t       adc[64];    // 32 PMs on V0C + 32 PMs on V0A
+  Float_t    time[80], time2[64], adc_gain[80];    
   fNdigits     =    0;  
   Float_t cPM  = fPhotoCathodeEfficiency * fPMGain;
 
@@ -112,8 +113,8 @@ void AliVZERODigitizer::Exec(Option_t* /*option*/)
   // as I have no beam burst structure - odd or even beam burst number
   
   // Reminder : We have 16 scintillating cells mounted on 8 PMs 
-  // on Ring 3 and Ring 4 in V0C - in principle I should add ADC outputs 
-  // on these rings... I do not do it...
+  // on Ring 3 and Ring 4 in V0C -  added to produce  ADC outputs 
+  // on these rings... 
    
   for(Int_t i=0; i<16; i++) { adc_gain[i]  = fCalibData->GetGain(i) ; };
   
@@ -165,7 +166,7 @@ void AliVZERODigitizer::Exec(Option_t* /*option*/)
       continue; }
     
     Float_t timeV0 = 1e12;      
-    for(Int_t i=0; i<80; i++) { adc[i]  = 0; time[i] = 0.0; }
+    for(Int_t i=0; i<80; i++) { map[i]  = 0; time[i] = 0.0; }
              
     TClonesArray* hits = vzero->Hits();
              
@@ -180,8 +181,8 @@ void AliVZERODigitizer::Exec(Option_t* /*option*/)
        AliVZEROhit* hit = (AliVZEROhit *)hits->UncheckedAt(iHit);
        Int_t nPhot = hit->Nphot();
        Int_t cell  = hit->Cell();                                    
-       adc[cell] += nPhot;
-       Float_t dt_scintillator = gRandom->Gaus(0,0.3);
+       map[cell] += nPhot;
+       Float_t dt_scintillator = gRandom->Gaus(0,0.7);
        time[cell] = dt_scintillator + 1e9*hit->Tof();
        if(time[cell] < timeV0) timeV0 = time[cell];
       }           // hit   loop
@@ -190,22 +191,44 @@ void AliVZERODigitizer::Exec(Option_t* /*option*/)
     loader->UnloadHits();
 
   }               // input loop
+
+// Now builds the scintillator cell response (80 cells i.e. 80 responses)
          
-  for (Int_t i=0; i<80; i++) {    
-     Float_t q1 = Float_t ( adc[i] )* cPM * kQe;
-     Float_t noise = gRandom->Gaus(10.5,3.22);
-     Float_t pmResponse  =  q1/kC*TMath::Power(ktheta/kthau,1/(1-ktheta/kthau)) 
-      + noise*1e-3;
-     adc[i] = Int_t( pmResponse * adc_gain[i]);
-     if(adc[i] > 0) {
-//         printf(" Event, cell, adc, tof = %d %d %d %f\n", 
-//                  outRunLoader->GetEventNumber(),i, adc[i], time[i]*100.0);
+   for (Int_t i=0; i<80; i++) {    
+       Float_t q1 = Float_t ( map[i] )* cPM * kQe;
+       Float_t noise = gRandom->Gaus(10.5,3.22);
+       Float_t pmResponse  =  q1/kC*TMath::Power(ktheta/kthau,1/(1-ktheta/kthau)) 
+        + noise*1e-3;
+       map[i] = Int_t( pmResponse * adc_gain[i]);
+     }
+     
+ 
+// Now transforms 80 cell responses into 64 photomultiplier responses 
+       
+   for (Int_t j=0; j<32; j++){
+       adc[j]  = map [j];
+       time2[j]= time[j];}
+       
+   for (Int_t j=48; j<80; j++){
+       adc[j-16]  = map [j];
+       time2[j-16]= time[j];}
+       
+   for (Int_t j=0; j<16; j++){
+       adc[16+j] = map [16 + 2*j]+ map [16 + 2*j + 1];
+       time2[16+j] = TMath::Min(time [16 + 2*j], time [16 + 2*j + 1]);}
+       
+// Now add digits to the digit Tree 
+        
+   for (Int_t i=0; i<64; i++) {      
+      if(adc[i] > 0) {
+//    printf(" Event, cell, adc, tof = %d %d %d %f\n", 
+//                  outRunLoader->GetEventNumber(),i, map[i], time[i]*100.0);
 //   multiply by 10 to have 100 ps per channel :
-     AddDigit(i, adc[i], Int_t(time[i]*10.0) );
-    } 
-
-  }
+      AddDigit(i, adc[i], Int_t(time2[i]*10.0) );
+     } 
+   }
 
+  
   treeD->Fill();
   outLoader->WriteDigits("OVERWRITE");  
   outLoader->UnloadDigits();     
@@ -213,13 +236,13 @@ void AliVZERODigitizer::Exec(Option_t* /*option*/)
 }
 
 //____________________________________________________________________________
-void AliVZERODigitizer::AddDigit(Int_t cellnumber, Int_t adc, Int_t time) 
+void AliVZERODigitizer::AddDigit(Int_t PMnumber, Int_t adc, Int_t time) 
  { 
  
 // Adds Digit 
  
   TClonesArray &ldigits = *fDigits;  
-  new(ldigits[fNdigits++]) AliVZEROdigit(cellnumber,adc,time);
+  new(ldigits[fNdigits++]) AliVZEROdigit(PMnumber,adc,time);
 }
 //____________________________________________________________________________
 void AliVZERODigitizer::ResetDigit()

diff --git a/VZERO/AliVZERODigitizer.h b/VZERO/AliVZERODigitizer.h
index 4c8612337fe57d793dfe27f4789277368230b551..99245cf8f0c4150f214d0c3b1e0f3deb7d10f202 100644 (file)
--- a/VZERO/AliVZERODigitizer.h
+++ b/VZERO/AliVZERODigitizer.h
@@ -32,7 +32,7 @@ class AliVZERODigitizer: public AliDigitizer {
    virtual Bool_t Init();
    virtual void   Exec(Option_t* option=0);
 
-   void AddDigit(Int_t cellnumber, Int_t adc, Int_t time);
+   void AddDigit(Int_t PMnumber, Int_t adc, Int_t time);
    void ResetDigit();
   
    AliVZEROCalibData *GetCalibData() const;

diff --git a/VZERO/AliVZEROTrigger.cxx b/VZERO/AliVZEROTrigger.cxx
index 23ceff60288d2242460518f1186b3e17578adf7e..31a95219b480cb30ca3cbf78356dd0bf6104d318 100644 (file)
--- a/VZERO/AliVZEROTrigger.cxx
+++ b/VZERO/AliVZEROTrigger.cxx
@@ -75,15 +75,15 @@ void AliVZEROTrigger::Trigger()
       //      vzeroDigitsTree->GetEvent(d);
       AliVZEROdigit* digit = (AliVZEROdigit*)vzeroDigits->At(d);
       
-      Int_t   cellNumber = digit->CellNumber();
+      Int_t   PMNumber   = digit->PMNumber();
       Float_t adc        = digit->ADC();
       Float_t tdc        = digit->Time(); // in 100 of picoseconds
       
-      if (cellNumber<=47 && adc>fAdcThresHold) {
+      if (PMNumber<=31 && adc>fAdcThresHold) {
        nLeftDig++;
        if (tdc<firstTimeLeft) firstTimeLeft = tdc;
       }        
-      if (cellNumber>=48 && adc>fAdcThresHold) {
+      if (PMNumber>=32 && adc>fAdcThresHold) {
        nRightDig++;
        if (tdc<firstTimeRight) firstTimeRight = tdc;
       }
@@ -113,7 +113,7 @@ void AliVZEROTrigger::Trigger()
     }
   }
   
-  AliDebug(1,Form("VZERO cells fired: %d (left) %d (right)", nLeftDig, nRightDig));
+  AliDebug(1,Form("VZERO PMs fired: %d (left) %d (right)", nLeftDig, nRightDig));
 
   return;
 }

diff --git a/VZERO/AliVZEROdigit.cxx b/VZERO/AliVZEROdigit.cxx
index dbf70818accd320d699d0eff106569a51ab7984b..bc6868902a2782675734d8d9a162200f1634e308 100644 (file)
--- a/VZERO/AliVZEROdigit.cxx
+++ b/VZERO/AliVZEROdigit.cxx
@@ -19,7 +19,7 @@ ClassImp(AliVZEROdigit)
 
 AliVZEROdigit::AliVZEROdigit()
 {
-  fCellNumber = 0;
+  fPMNumber   = 0;
   fADC        = 0;
   fTime       = 0;
 }
@@ -36,9 +36,9 @@ AliVZEROdigit::AliVZEROdigit(Int_t* tracks, Int_t *digits):
   fEvent      =  digits[0];  
 }
 
-AliVZEROdigit::AliVZEROdigit(Int_t cellnumber, Int_t adc, Int_t time)
+AliVZEROdigit::AliVZEROdigit(Int_t PMnumber, Int_t adc, Int_t time)
 {  
-  fCellNumber = cellnumber;
+  fPMNumber   = PMnumber;
   fADC        = adc;
   fTime       = time;
 }

diff --git a/VZERO/AliVZEROdigit.h b/VZERO/AliVZEROdigit.h
index 067aab154b35b8afd61cf1d531928d29632ac431..1711b5cb4b1ccf377b95dc35dabdeb52531dbf78 100644 (file)
--- a/VZERO/AliVZEROdigit.h
+++ b/VZERO/AliVZEROdigit.h
@@ -13,9 +13,9 @@ class AliVZEROdigit: public AliDigit  {
  public:
     AliVZEROdigit();
     AliVZEROdigit(Int_t* tracks, Int_t* digits);
-    AliVZEROdigit(Int_t /* cellnumber */, Int_t /* adc */, Int_t /* Time */);
+    AliVZEROdigit(Int_t /* PMnumber */, Int_t /* ADC */, Int_t /* Time */);
     virtual ~AliVZEROdigit() {};
-    Int_t   CellNumber()  const {return fCellNumber;}    
+    Int_t   PMNumber()  const {return fPMNumber;}    
     Int_t   ADC()  const {return fADC;}
     Int_t   Time() const {return fTime;}
      
@@ -24,7 +24,7 @@ class AliVZEROdigit: public AliDigit  {
     
   protected:
     Int_t  fEvent;         // Event number  
-    Int_t  fCellNumber;    // Scintillator cell number
+    Int_t  fPMNumber;      // Photomultiplier number (0 to 63)
     Int_t  fADC;           // ADC response
     Int_t  fTime;          // Time of Flight