Reconstructor for digits and fix of some bugs
authormbroz <Michal.Broz@cern.ch>
Fri, 17 Oct 2014 08:21:13 +0000 (10:21 +0200)
committermbroz <Michal.Broz@cern.ch>
Fri, 17 Oct 2014 08:21:13 +0000 (10:21 +0200)
AD/AliADQADataMakerRec.cxx
AD/AliADRawStream.cxx
AD/AliADReconstructor.cxx
AD/AliADReconstructor.h

index 3373b22..2f52d9b 100644 (file)
@@ -110,14 +110,14 @@ AliADCalibData* AliADQADataMakerRec::GetCalibData() const
 
   AliCDBEntry *entry=0;
 
-  entry = man->Get("AD/Calib/Data",fRun);
-  if(!entry){
-    AliWarning("Load of calibration data from default storage failed!");
-    AliWarning("Calibration data will be loaded from local storage ($ALICE_ROOT)");
+  //entry = man->Get("AD/Calib/Data",fRun);
+  //if(!entry){
+    //AliWarning("Load of calibration data from default storage failed!");
+    //AliWarning("Calibration data will be loaded from local storage ($ALICE_ROOT)");
        
     man->SetDefaultStorage("local://$ALICE_ROOT/OCDB");
     entry = man->Get("AD/Calib/Data",fRun);
-  }
+  //}
   // Retrieval of data in directory AD/Calib/Data:
 
   AliADCalibData *calibdata = 0;
@@ -220,14 +220,14 @@ void AliADQADataMakerRec::MakeDigits()
 }
 
 //____________________________________________________________________________
-void AliADQADataMakerRec::MakeDigits(TTree *digitTree)
+void AliADQADataMakerRec::MakeDigits(TTree* /*digitTree*/)
 {
 
 }
 
 
 //____________________________________________________________________________
-void AliADQADataMakerRec::MakeESDs(AliESDEvent * esd)
+void AliADQADataMakerRec::MakeESDs(AliESDEvent* /*esd*/)
 {
  
 }
@@ -477,10 +477,10 @@ void AliADQADataMakerRec::MakeRaws(AliRawReader* rawReader)
       // Fill HPTDC Time Histograms
       timeCorr[offlineCh] = CorrectLeadingTime(offlineCh,time[offlineCh],adc[offlineCh]);
 
-      const Float_t p1 = 2.50; // photostatistics term in the time resolution
-      const Float_t p2 = 3.00; // sleewing related term in the time resolution
+      //const Float_t p1 = 2.50; // photostatistics term in the time resolution
+      //const Float_t p2 = 3.00; // sleewing related term in the time resolution
       if(timeCorr[offlineCh]>-1024 + 1.e-6){
-       Float_t nphe = adc[offlineCh]*kChargePerADC/(fCalibData->GetGain(offlineCh)*TMath::Qe());
+       //Float_t nphe = adc[offlineCh]*kChargePerADC/(fCalibData->GetGain(offlineCh)*TMath::Qe());
        Float_t timeErr = 1;
        /*/
        if (nphe>1.e-6) timeErr = TMath::Sqrt(kIntTimeRes*kIntTimeRes+
@@ -592,7 +592,7 @@ void AliADQADataMakerRec::MakeRaws(AliRawReader* rawReader)
 }
 
 //____________________________________________________________________________ 
-Float_t AliADQADataMakerRec::CorrectLeadingTime(Int_t i, Float_t time, Float_t adc) const
+Float_t AliADQADataMakerRec::CorrectLeadingTime(Int_t /*i*/, Float_t time, Float_t /*adc*/) const
 {
   // Correct the leading time
   // for slewing effect and
index 16de35e..f9e9b3d 100644 (file)
@@ -41,8 +41,8 @@ AliADRawStream::AliADRawStream(AliRawReader* rawReader) :
   // select the raw data corresponding to
   // the AD detector id
   fRawReader->Reset();
-  AliDebug(1,Form("Selecting raw data for detector %d",AliDAQ::DetectorID("AD")));
-  fRawReader->Select("AD");
+  AliDebug(1,Form("Selecting raw data for detector %d",AliDAQ::DetectorID("VZERO")));
+  fRawReader->Select("VZERO");
 
   // Initalize the containers
   for(Int_t i = 0; i < kNChannels; i++) {
@@ -106,9 +106,9 @@ Bool_t AliADRawStream::Next()
   if (!fRawReader->ReadNextData(fData)) return kFALSE;
   if (fRawReader->GetDataSize() == 0) return kFALSE;
      
-  if (fRawReader->GetDataSize() != 1568) {
-     fRawReader->AddFatalErrorLog(kRawDataSizeErr,Form("size %d != 1568",fRawReader->GetDataSize()));
-     AliWarning(Form("Wrong AD raw data size: %d, expected 1568 bytes!",fRawReader->GetDataSize()));
+  if (fRawReader->GetDataSize() != 5936) {
+     fRawReader->AddFatalErrorLog(kRawDataSizeErr,Form("size %d != 5936",fRawReader->GetDataSize()));
+     AliWarning(Form("Wrong AD raw data size: %d, expected 5936 bytes!",fRawReader->GetDataSize()));
      return kFALSE;
   }
 
@@ -122,8 +122,14 @@ Bool_t AliADRawStream::Next()
 
   for(Int_t iBunch = 0; iBunch < kNBunches; iBunch++)
      fBunchNumbers[iBunch] = GetNextWord();
-  for (Int_t  iCIU = 0; iCIU < kNCIUBoards; iCIU++) { 
+  
+  Int_t iCIU=0;
+  for (Int_t  iV0CIU = 0; iV0CIU < 8; iV0CIU++) {
+    
+    if(iV0CIU != 1 || iV0CIU != 5) {
+      for(Int_t iWord = 0; iWord<182; iWord++) GetNextWord();
+      continue;
+       }
  
   // decoding of one Channel Interface Unit numbered iCIU - there are 8 channels per CIU (and 2 CIUs) :
   
@@ -185,9 +191,9 @@ Bool_t AliADRawStream::Next()
       fTime[iChannel]  = time & 0xfff;
       fWidth[iChannel] = ((time >> 12) & 0x7f); // HPTDC used in pairing mode
     }
-    
+    iCIU++;
     // End of decoding of one CIU card
-    // printf("Number of bytes used at end of reading CIU card number %d %d \n\n", iCIU+1, fPosition); 
+    AliWarning(Form("Number of bytes used at end of reading CIU card number %d %d", iCIU+1, fPosition)); 
     
   } // end of decoding the eight CIUs
     
index 1ceac83..c102723 100644 (file)
 //                                                                          //
 //  Class for AD reconstruction                                         //
 //////////////////////////////////////////////////////////////////////////////
+#include <TParameter.h>
 
 #include "AliRawReader.h"
+#include "AliGRPObject.h"
+#include "AliCDBManager.h"
+#include "AliCDBStorage.h"
+#include "AliCDBEntry.h"
+#include "AliESDEvent.h"
 
 #include "AliADReconstructor.h"
-#include "AliESDEvent.h"
 #include "AliADdigit.h"
 #include "AliESDAD.h"
+#include "AliADConst.h"
+#include "AliADCalibData.h"
+#include "AliADRawStream.h"
 
 ClassImp(AliADReconstructor)
-
+//_____________________________________________________________________________
 AliADReconstructor:: AliADReconstructor():
   AliReconstructor(),
   fESDAD(0x0),
+  fCalibData(NULL),
   fDigitsArray(0)
+
 {
+  fCalibData = GetCalibData();
   // Default constructor  
   // Get calibration data
 
@@ -63,12 +74,71 @@ void AliADReconstructor::Init()
     fESDAD  = new AliESDAD;
 }
 
-void AliADReconstructor::ConvertDigits(AliRawReader* /*rawReader*/, TTree* /*digitsTree*/) const
+//_____________________________________________________________________________
+void AliADReconstructor::ConvertDigits(AliRawReader* rawReader, TTree* digitsTree) const
 {
+// converts RAW to digits 
+
+  if (!digitsTree) {
+    AliError("No digits tree!");
+    return;
+  }
+
+  if (!fDigitsArray){
+    fDigitsArray = new TClonesArray("AliADdigit", 16);
+    digitsTree->Branch("ADDigit", &fDigitsArray);
+    }
+
+  rawReader->Reset();
+  AliADRawStream rawStream(rawReader);
+  if (rawStream.Next()) { 
+
+    Int_t aBBflagsADA = 0;
+    Int_t aBBflagsADC = 0;
+    Int_t aBGflagsADA = 0;
+    Int_t aBGflagsADC = 0;
+
+    for(Int_t iChannel=0; iChannel < 16; ++iChannel) {
+      Int_t offlineCh = rawStream.GetOfflineChannel(iChannel);
+      // ADC charge samples
+      Short_t chargeADC[kNClocks];
+      for(Int_t iClock=0; iClock < kNClocks; ++iClock) {
+       chargeADC[iClock] = rawStream.GetPedestal(iChannel,iClock);
+      }
+      // Integrator flag
+      Bool_t integrator = rawStream.GetIntegratorFlag(iChannel,kNClocks/2);
+      // Beam-beam and beam-gas flags
+      if(offlineCh<8) {
+       if (rawStream.GetBBFlag(iChannel,kNClocks/2)) aBBflagsADC |= (1 << offlineCh);
+       if (rawStream.GetBGFlag(iChannel,kNClocks/2)) aBGflagsADC |= (1 << offlineCh);
+      } else {
+       if (rawStream.GetBBFlag(iChannel,kNClocks/2)) aBBflagsADA |= (1 << (offlineCh-32));
+       if (rawStream.GetBGFlag(iChannel,kNClocks/2)) aBGflagsADA |= (1 << (offlineCh-32));
+      }
+      // HPTDC data (leading time and width)
+      Int_t board = AliADCalibData::GetBoardNumber(offlineCh);
+      Float_t time = rawStream.GetTime(iChannel)*fCalibData->GetTimeResolution(board);
+      Float_t width = rawStream.GetWidth(iChannel)*fCalibData->GetWidthResolution(board);
+      // Add a digit
+      if(!fCalibData->IsChannelDead(iChannel)){
+         new ((*fDigitsArray)[fDigitsArray->GetEntriesFast()]) AliADdigit(offlineCh, time, width,integrator, chargeADC);
+      }
+    }
+    // Store the BB and BG flags in the digits tree (user info)
+    digitsTree->GetUserInfo()->Add(new TParameter<int>("BBflagsADA",aBBflagsADA));
+    digitsTree->GetUserInfo()->Add(new TParameter<int>("BBflagsADC",aBBflagsADC));
+    digitsTree->GetUserInfo()->Add(new TParameter<int>("BGflagsADA",aBGflagsADA));
+    digitsTree->GetUserInfo()->Add(new TParameter<int>("BGflagsADC",aBGflagsADC));
+
+
+    digitsTree->Fill();
+  }
+
+  fDigitsArray->Clear();
 
-  printf("Converting digits for AD .. not implemented \n");
 }
 
+//_____________________________________________________________________________
 void AliADReconstructor::FillESD(TTree* digitsTree, TTree* /*clustersTree*/,AliESDEvent* esd) const
 {
 
@@ -117,4 +187,30 @@ void AliADReconstructor::FillESD(TTree* digitsTree, TTree* /*clustersTree*/,AliE
   fDigitsArray->Clear();
 }
 
+//_____________________________________________________________________________
+AliADCalibData* AliADReconstructor::GetCalibData() const
+{
+  AliCDBManager *man = AliCDBManager::Instance();
+
+  AliCDBEntry *entry=0;
+
+  //entry = man->Get("AD/Calib/Data");
+  //if(!entry){
+    //AliWarning("Load of calibration data from default storage failed!");
+    //AliWarning("Calibration data will be loaded from local storage ($ALICE_ROOT)");
+       
+    man->SetDefaultStorage("local://$ALICE_ROOT/OCDB");
+    man->SetRun(1);
+    entry = man->Get("AD/Calib/Data");
+  //}
+  // Retrieval of data in directory AD/Calib/Data:
+
+  AliADCalibData *calibdata = 0;
+
+  if (entry) calibdata = (AliADCalibData*) entry->GetObject();
+  if (!calibdata)  AliFatal("No calibration data from calibration database !");
+
+  return calibdata;
+}
+
 
index 1024850..14711b3 100644 (file)
 
 #include "AliReconstructor.h"
 #include "AliLog.h"
+#include "AliADConst.h"
 
 class AliESDAD;
 class AliESDEvent;
+class AliADCalibData;
 
 class AliADReconstructor: public AliReconstructor {
 public:
@@ -37,16 +39,17 @@ public:
   virtual Bool_t HasDigitConversion() const { return kTRUE; }
   virtual void ConvertDigits(AliRawReader* rawReader, TTree* digitsTree) const;
 
+  AliADCalibData *GetCalibData() const; 
 
 protected:
 
   AliESDAD*        fESDAD;      // AD ESD object  
 
 private:
-  AliADReconstructor(const AliADReconstructor&); //Not implemented
-  AliADReconstructor& operator = (const AliADReconstructor&); //Not implemented
+  AliADReconstructor(const AliADReconstructor &reconstructor); //Not implemented
+  AliADReconstructor& operator = (const AliADReconstructor &reconstructor); //Not implemented
   
-
+  AliADCalibData* fCalibData;      //! calibration data
   mutable TClonesArray *fDigitsArray;  // clones-array for ConvertDigits() and FillESD()
 
   ClassDef(AliADReconstructor, 1)  // class for the AD reconstruction