Including pedestal calibration for time bins
authormarian <marian@f7af4fe6-9843-0410-8265-dc069ae4e863>
Wed, 24 Oct 2007 11:25:21 +0000 (11:25 +0000)
committermarian <marian@f7af4fe6-9843-0410-8265-dc069ae4e863>
Wed, 24 Oct 2007 11:25:21 +0000 (11:25 +0000)
+
Coding convention violation  (Christian)

TPC/AliTPCCalibPedestal.cxx
TPC/AliTPCCalibPedestal.h
TPC/AliTPCmapper.cxx
TPC/AliTPCmapper.h
TPC/TPCPEDESTALda.cxx

index b28ea95..bce5ce3 100644 (file)
 // padPedestal->MakeHisto2D()->Draw("colz");  //Draw A-Side Pedestal Information
 // padNoise->MakeHisto2D()->Draw("colz");  //Draw A-Side Noise Information
 //
+
 /*
  example: fill pedestal with gausschen noise
  AliTPCCalibPedestal ped;
  ped.GetCalRocPedestal(36)->Draw("colz");
  c2->cd(4);
  ped.GetCalRocRMS(36)->Draw("colz");
-
-
 */
 
+//
+// Time dependent pedestals:
+//
+// If wished there is the possibility to calculate for each channel and time bin
+// the mean pedestal [pedestals(t)]. This is done by
+//
+// 1) setting SetTimeAnalysis(kTRUE),
+// 2) processing the data by looping over the events using ProcessEvent(..)
+// 3) calling the Analyse() and AnalyseTime(nevents) functions (providing nevents)
+// 4) getting the pedestals(t) using   TArrayF **timePed = calibPedestal.GetTimePedestals();
+// 5) looking at values using   timePed[row][pad].At(timebin)
+//
+// This functionality is intended to be used on an LDC bu the detector algorithm
+// (TPCPEDESTALda) to generate a data set used for configuration of the pattern
+// memory for baseline subtraction in the ALTROs. Later the information should also
+// be stored as reference data.
+//
 
 
 ClassImp(AliTPCCalibPedestal)
@@ -189,15 +205,19 @@ AliTPCCalibPedestal::AliTPCCalibPedestal() : /*FOLD00*/
   fAdcMin(1),
   fAdcMax(100),
   fOldRCUformat(kTRUE),
+  fTimeAnalysis(kFALSE),
   fROC(AliTPCROC::Instance()),
   fCalRocArrayPedestal(72),
   fCalRocArrayRMS(72),
-  fHistoPedestalArray(72)
+  fHistoPedestalArray(72),
+  fTimeSignal(NULL)
 {
-    //
-    // default constructor
-    //
+  //
+  // default constructor
+  //
 }
+
+
 //_____________________________________________________________________
 AliTPCCalibPedestal::AliTPCCalibPedestal(const AliTPCCalibPedestal &ped) : /*FOLD00*/
   TObject(ped),
@@ -205,30 +225,34 @@ AliTPCCalibPedestal::AliTPCCalibPedestal(const AliTPCCalibPedestal &ped) : /*FOL
   fLastTimeBin(ped.GetLastTimeBin()),
   fAdcMin(ped.GetAdcMin()),
   fAdcMax(ped.GetAdcMax()),
-  fOldRCUformat(kTRUE),
+  fOldRCUformat(ped.fOldRCUformat),
+  fTimeAnalysis(ped.fTimeAnalysis),
   fROC(AliTPCROC::Instance()),
   fCalRocArrayPedestal(72),
   fCalRocArrayRMS(72),
-  fHistoPedestalArray(72)
+  fHistoPedestalArray(72),
+  fTimeSignal(ped.fTimeSignal)
 {
-    //
-    // copy constructor
-    //
-    for (Int_t iSec = 0; iSec < 72; ++iSec){
-       const AliTPCCalROC *calPed = (AliTPCCalROC*)ped.fCalRocArrayPedestal.UncheckedAt(iSec);
-       const AliTPCCalROC *calRMS = (AliTPCCalROC*)ped.fCalRocArrayRMS.UncheckedAt(iSec);
-       const TH2F         *hPed   = (TH2F*)ped.fHistoPedestalArray.UncheckedAt(iSec);
-
-       if ( calPed != 0x0 ) fCalRocArrayPedestal.AddAt(new AliTPCCalROC(*calPed), iSec);
-       if ( calRMS != 0x0 ) fCalRocArrayRMS.AddAt(new AliTPCCalROC(*calRMS), iSec);
-
-       if ( hPed != 0x0 ){
-           TH2F *hNew = new TH2F(*hPed);
-           hNew->SetDirectory(0);
-           fHistoPedestalArray.AddAt(hNew,iSec);
-       }
+  //
+  // copy constructor
+  //
+  for (Int_t iSec = 0; iSec < 72; ++iSec){
+    const AliTPCCalROC *calPed = (AliTPCCalROC*)ped.fCalRocArrayPedestal.UncheckedAt(iSec);
+    const AliTPCCalROC *calRMS = (AliTPCCalROC*)ped.fCalRocArrayRMS.UncheckedAt(iSec);
+    const TH2F         *hPed   = (TH2F*)ped.fHistoPedestalArray.UncheckedAt(iSec);
+    
+    if ( calPed != 0x0 ) fCalRocArrayPedestal.AddAt(new AliTPCCalROC(*calPed), iSec);
+    if ( calRMS != 0x0 ) fCalRocArrayRMS.AddAt(new AliTPCCalROC(*calRMS), iSec);
+    
+    if ( hPed != 0x0 ){
+      TH2F *hNew = new TH2F(*hPed);
+      hNew->SetDirectory(0);
+      fHistoPedestalArray.AddAt(hNew,iSec);
     }
+  }
 }
+
+
 //_____________________________________________________________________
 AliTPCCalibPedestal& AliTPCCalibPedestal::operator = (const  AliTPCCalibPedestal &source)
 {
@@ -240,6 +264,8 @@ AliTPCCalibPedestal& AliTPCCalibPedestal::operator = (const  AliTPCCalibPedestal
 
   return *this;
 }
+
+
 //_____________________________________________________________________
 AliTPCCalibPedestal::~AliTPCCalibPedestal() /*FOLD00*/
 {
@@ -247,36 +273,88 @@ AliTPCCalibPedestal::~AliTPCCalibPedestal() /*FOLD00*/
   // destructor
   //
 
-    fCalRocArrayPedestal.Delete();
-    fCalRocArrayRMS.Delete();
-    fHistoPedestalArray.Delete();
+  fCalRocArrayPedestal.Delete();
+  fCalRocArrayRMS.Delete();
+  fHistoPedestalArray.Delete();
+
+  if ( fTimeSignal ) {
+    for (Int_t i = 0; i < 159; i++) {
+      delete [] fTimeSignal[i];
+      fTimeSignal[i] = 0;
+    }
+    delete [] fTimeSignal;
+    fTimeSignal = 0;
+  }
+}
+
+
+//_____________________________________________________________________
+void AliTPCCalibPedestal::SetTimeAnalysis(Bool_t time)
+{
+  //
+  // Use time dependent analysis: Pedestals are analysed as a function
+  // of the drift time. There is one mean value generated for each time
+  // bin and each channel. It can be used as reference data and for
+  // configuration of the ALTRO pattern memory for baseline subtraction.
+  //
+  // ATTENTION: Use only on LDC in TPCPEDESTALda! On a LDC we get data
+  // only from one sector. For the full TPC we would need a lot of
+  // memory (36*159*140*1024*4bytes = 3.3GB)!
+  //
+
+  fTimeAnalysis = time;
+
+  if ( !fTimeAnalysis ) return;
+
+  // prepare array for one sector (159*140*1024*4bytes = 92MB):
+  fTimeSignal = new TArrayF*[159];
+  for (Int_t i = 0; i < 159; i++) {  // padrows
+    fTimeSignal[i] = new TArrayF[140];
+    for (Int_t j = 0; j < 140; j++) {  // pads per row
+      fTimeSignal[i][j].Set(1024);
+      for (Int_t k = 0; k < 1024; k++) {  // time bins per pad
+       fTimeSignal[i][j].AddAt(0., k);
+      }
+    }      
+  }
 }
+
+
 //_____________________________________________________________________
 Int_t AliTPCCalibPedestal::Update(const Int_t icsector, /*FOLD00*/
-                               const Int_t icRow,
-                               const Int_t icPad,
-                               const Int_t icTimeBin,
-                               const Float_t csignal)
+                                 const Int_t icRow,
+                                 const Int_t icPad,
+                                 const Int_t icTimeBin,
+                                 const Float_t csignal)
 {
-    //
-    // Signal filling methode 
-    //
+  //
+  // Signal filling method
+  //
 
-    //return if we are out of the specified time bin or adc range
-    if ( (icTimeBin>fLastTimeBin) || (icTimeBin<fFirstTimeBin) ) return 0;
-    if ( ((Int_t)csignal>fAdcMax) || ((Int_t)csignal<fAdcMin)  ) return 0;
+  // Time dependent pedestals
+  if ( fTimeAnalysis ) {
+    if ( icsector < 36 ) // IROC
+      fTimeSignal[icRow][icPad].AddAt(fTimeSignal[icRow][icPad].At(icTimeBin)+csignal, icTimeBin);
+    else 
+      fTimeSignal[icRow+63][icPad].AddAt(fTimeSignal[icRow+63][icPad].At(icTimeBin)+csignal, icTimeBin);
+  }
+  //return if we are out of the specified time bin or adc range
+  if ( (icTimeBin>fLastTimeBin) || (icTimeBin<fFirstTimeBin) ) return 0;
+  if ( ((Int_t)csignal>fAdcMax) || ((Int_t)csignal<fAdcMin)  ) return 0;
 
-    Int_t iChannel  = fROC->GetRowIndexes(icsector)[icRow]+icPad; //  global pad position in sector
+  Int_t iChannel  = fROC->GetRowIndexes(icsector)[icRow]+icPad; //  global pad position in sector
 
-    // fast filling methode.
-    // Attention: the entry counter of the histogram is not increased
-    //            this means that e.g. the colz draw option gives an empty plot
-    Int_t bin = (iChannel+1)*(fAdcMax-fAdcMin+2)+((Int_t)csignal-fAdcMin+1);
+  // fast filling methode.
+  // Attention: the entry counter of the histogram is not increased
+  //            this means that e.g. the colz draw option gives an empty plot
+  Int_t bin = (iChannel+1)*(fAdcMax-fAdcMin+2)+((Int_t)csignal-fAdcMin+1);
 
-    GetHistoPedestal(icsector,kTRUE)->GetArray()[bin]++;
+  GetHistoPedestal(icsector,kTRUE)->GetArray()[bin]++;
 
-    return 0;
+  return 0;
 }
+
+
 //_____________________________________________________________________
 Bool_t AliTPCCalibPedestal::ProcessEvent(AliTPCRawStream *rawStream)
 {
@@ -290,18 +368,20 @@ Bool_t AliTPCCalibPedestal::ProcessEvent(AliTPCRawStream *rawStream)
 
   while (rawStream->Next()) {
 
-      Int_t isector  = rawStream->GetSector();                       //  current sector
-      Int_t iRow     = rawStream->GetRow();                          //  current row
-      Int_t iPad     = rawStream->GetPad();                          //  current pad
-      Int_t iTimeBin = rawStream->GetTime();                         //  current time bin
-      Float_t signal = rawStream->GetSignal();                       //  current ADC signal
-
-      Update(isector,iRow,iPad,iTimeBin,signal);
-      withInput = kTRUE;
+    Int_t iSector  = rawStream->GetSector();      //  current ROC
+    Int_t iRow     = rawStream->GetRow();         //  current row
+    Int_t iPad     = rawStream->GetPad();         //  current pad
+    Int_t iTimeBin = rawStream->GetTime();        //  current time bin
+    Float_t signal = rawStream->GetSignal();      //  current ADC signal
+    
+    Update(iSector,iRow,iPad,iTimeBin,signal);
+    withInput = kTRUE;
   }
 
   return withInput;
 }
+
+
 //_____________________________________________________________________
 Bool_t AliTPCCalibPedestal::ProcessEvent(AliRawReader *rawReader)
 {
@@ -309,24 +389,26 @@ Bool_t AliTPCCalibPedestal::ProcessEvent(AliRawReader *rawReader)
   //  Event processing loop - AliRawReader
   //
 
-
   AliTPCRawStream rawStream(rawReader);
-
   rawReader->Select("TPC");
-
   return ProcessEvent(&rawStream);
 }
+
+
 //_____________________________________________________________________
 Bool_t AliTPCCalibPedestal::ProcessEvent(eventHeaderStruct *event)
 {
   //
   //  process date event
   //
-    AliRawReader *rawReader = new AliRawReaderDate((void*)event);
-    Bool_t result=ProcessEvent(rawReader);
-    delete rawReader;
-    return result;
+
+  AliRawReader *rawReader = new AliRawReaderDate((void*)event);
+  Bool_t result=ProcessEvent(rawReader);
+  delete rawReader;
+  return result;
 }
+
+
 //_____________________________________________________________________
 Bool_t AliTPCCalibPedestal::TestEvent() /*FOLD00*/
 {
@@ -350,6 +432,8 @@ Bool_t AliTPCCalibPedestal::TestEvent() /*FOLD00*/
     }
     return kTRUE;
 }
+
+
 //_____________________________________________________________________
 TH2F* AliTPCCalibPedestal::GetHisto(Int_t sector, TObjArray *arr, /*FOLD00*/
                                  Int_t nbinsY, Float_t ymin, Float_t ymax,
@@ -377,6 +461,8 @@ TH2F* AliTPCCalibPedestal::GetHisto(Int_t sector, TObjArray *arr, /*FOLD00*/
     arr->AddAt(hist,sector);
     return hist;
 }
+
+
 //_____________________________________________________________________
 TH2F* AliTPCCalibPedestal::GetHistoPedestal(Int_t sector, Bool_t force) /*FOLD00*/
 {
@@ -387,6 +473,8 @@ TH2F* AliTPCCalibPedestal::GetHistoPedestal(Int_t sector, Bool_t force) /*FOLD00
     TObjArray *arr = &fHistoPedestalArray;
     return GetHisto(sector, arr, fAdcMax-fAdcMin, fAdcMin, fAdcMax, "Pedestal", force);
 }
+
+
 //_____________________________________________________________________
 AliTPCCalROC* AliTPCCalibPedestal::GetCalRoc(Int_t sector, TObjArray* arr, Bool_t force) /*FOLD00*/
 {
@@ -404,6 +492,8 @@ AliTPCCalROC* AliTPCCalibPedestal::GetCalRoc(Int_t sector, TObjArray* arr, Bool_
     arr->AddAt(croc,sector);
     return croc;
 }
+
+
 //_____________________________________________________________________
 AliTPCCalROC* AliTPCCalibPedestal::GetCalRocPedestal(Int_t sector, Bool_t force) /*FOLD00*/
 {
@@ -414,6 +504,8 @@ AliTPCCalROC* AliTPCCalibPedestal::GetCalRocPedestal(Int_t sector, Bool_t force)
     TObjArray *arr = &fCalRocArrayPedestal;
     return GetCalRoc(sector, arr, force);
 }
+
+
 //_____________________________________________________________________
 AliTPCCalROC* AliTPCCalibPedestal::GetCalRocRMS(Int_t sector, Bool_t force) /*FOLD00*/
 {
@@ -424,93 +516,123 @@ AliTPCCalROC* AliTPCCalibPedestal::GetCalRocRMS(Int_t sector, Bool_t force) /*FO
     TObjArray *arr = &fCalRocArrayRMS;
     return GetCalRoc(sector, arr, force);
 }
+
+
 //_____________________________________________________________________
 void AliTPCCalibPedestal::Merge(AliTPCCalibPedestal *ped)
 {
-    //
-    //  Merge reference histograms of sig to the current AliTPCCalibSignal
-    //
+  //
+  //  Merge reference histograms of sig to the current AliTPCCalibSignal
+  //
 
-    //merge histograms
-    for (Int_t iSec=0; iSec<72; ++iSec){
-       TH2F *hRefPedMerge   = ped->GetHistoPedestal(iSec);
+  // merge histograms
+  for (Int_t iSec=0; iSec<72; ++iSec){
+    TH2F *hRefPedMerge   = ped->GetHistoPedestal(iSec);
+
+    if ( hRefPedMerge ){
+      TDirectory *dir = hRefPedMerge->GetDirectory(); hRefPedMerge->SetDirectory(0);
+      TH2F *hRefPed   = GetHistoPedestal(iSec);
+      if ( hRefPed ) hRefPed->Add(hRefPedMerge);
+      else {
+       TH2F *hist = new TH2F(*hRefPedMerge);
+       hist->SetDirectory(0);
+       fHistoPedestalArray.AddAt(hist, iSec);
+      }
+      hRefPedMerge->SetDirectory(dir);
+    }
+  }
 
+  // merge array
+  // ...
 
-       if ( hRefPedMerge ){
-           TDirectory *dir = hRefPedMerge->GetDirectory(); hRefPedMerge->SetDirectory(0);
-           TH2F *hRefPed   = GetHistoPedestal(iSec);
-           if ( hRefPed ) hRefPed->Add(hRefPedMerge);
-           else {
-               TH2F *hist = new TH2F(*hRefPedMerge);
-                hist->SetDirectory(0);
-               fHistoPedestalArray.AddAt(hist, iSec);
-           }
-           hRefPedMerge->SetDirectory(dir);
-       }
-    }
 }
+
+
 //_____________________________________________________________________
 void AliTPCCalibPedestal::Analyse() /*FOLD00*/
 {
-    //
-    //  Calculate calibration constants
-    //
+  //
+  //  Calculate calibration constants
+  //
 
-    Int_t nbinsAdc = fAdcMax-fAdcMin;
+  Int_t nbinsAdc = fAdcMax-fAdcMin;
 
-    TVectorD param(3);
-    TMatrixD dummy(3,3);
+  TVectorD param(3);
+  TMatrixD dummy(3,3);
 
-    Float_t *array_hP=0;
+  Float_t *array_hP=0;  
 
+  for (Int_t iSec=0; iSec<72; ++iSec){
+    TH2F *hP = GetHistoPedestal(iSec);
+    if ( !hP ) continue;
 
-    for (Int_t iSec=0; iSec<72; ++iSec){
-       TH2F *hP = GetHistoPedestal(iSec);
-        if ( !hP ) continue;
+    AliTPCCalROC *rocPedestal = GetCalRocPedestal(iSec,kTRUE);
+    AliTPCCalROC *rocRMS      = GetCalRocRMS(iSec,kTRUE);
 
-       AliTPCCalROC *rocPedestal = GetCalRocPedestal(iSec,kTRUE);
-       AliTPCCalROC *rocRMS      = GetCalRocRMS(iSec,kTRUE);
+    array_hP = hP->GetArray();
+    UInt_t nChannels = fROC->GetNChannels(iSec);
 
-       array_hP = hP->GetArray();
-        UInt_t nChannels = fROC->GetNChannels(iSec);
+    for (UInt_t iChannel=0; iChannel<nChannels; ++iChannel){
+      Int_t offset = (nbinsAdc+2)*(iChannel+1)+1;
+      Double_t ret = AliMathBase::FitGaus(array_hP+offset,nbinsAdc,fAdcMin,fAdcMax,&param,&dummy);
+      // if the fitting failed set noise and pedestal to 0
+      if ( ret == -4 ) {
+       param[1]=0;
+       param[2]=0;
+      }
+      rocPedestal->SetValue(iChannel,param[1]);
+      rocRMS->SetValue(iChannel,param[2]);
+    }
+  }
+}
 
-       for (UInt_t iChannel=0; iChannel<nChannels; ++iChannel){
-            Int_t offset = (nbinsAdc+2)*(iChannel+1)+1;
-           Double_t ret = AliMathBase::FitGaus(array_hP+offset,nbinsAdc,fAdcMin,fAdcMax,&param,&dummy);
-            // if the fitting failed set noise and pedestal to 0
-           if ( ret == -4 ) {
-               param[1]=0;
-               param[2]=0;
-           }
-           rocPedestal->SetValue(iChannel,param[1]);
-            rocRMS->SetValue(iChannel,param[2]);
+
+//_____________________________________________________________________
+void AliTPCCalibPedestal::AnalyseTime(Int_t nevents)
+{
+  //
+  // Calculate for each channel and time bin the mean pedestal. This
+  // is used on LDC by TPCPEDESTALda to generate data used for configuration
+  // of the pattern memory for baseline subtraction in the ALTROs.
+  //
+
+  if ( nevents <= 0 ) return;
+  if ( fTimeAnalysis ) {
+    for (Int_t i = 0; i < 159; i++) {  // padrows
+      for (Int_t j = 0; j < 140; j++) {  // pads per row
+       for (Int_t k = 0; k < 1024; k++) {  // time bins per pad
+         fTimeSignal[i][j].AddAt(fTimeSignal[i][j].At(k)/(Float_t)nevents, k);
        }
+      }
     }
+  }
 }
+
+
 //_____________________________________________________________________
 void AliTPCCalibPedestal::DumpToFile(const Char_t *filename, const Char_t *dir, Bool_t append) /*FOLD00*/
 {
-    //
-    //  Write class to file
-    //
+  //
+  //  Write class to file
+  //
 
-    TString sDir(dir);
-    TString option;
+  TString sDir(dir);
+  TString option;
 
-    if ( append )
-       option = "update";
-    else
-        option = "recreate";
+  if ( append )
+    option = "update";
+  else
+    option = "recreate";
 
-    TDirectory *backup = gDirectory;
-    TFile f(filename,option.Data());
-    f.cd();
-    if ( !sDir.IsNull() ){
-       f.mkdir(sDir.Data());
-       f.cd(sDir);
-    }
-    this->Write();
-    f.Close();
+  TDirectory *backup = gDirectory;
+  TFile f(filename,option.Data());
+  f.cd();
+  if ( !sDir.IsNull() ){
+    f.mkdir(sDir.Data());
+    f.cd(sDir);
+  }
+  this->Write();
+  f.Close();
 
-    if ( backup ) backup->cd();
+  if ( backup ) backup->cd();
 }
index 48ef360..52945f7 100644 (file)
@@ -8,14 +8,15 @@
 #include <TObject.h>
 #include <TObjArray.h>
 
+class TArrayF;
 class TH2F;
 class TTreeSRedirector;
 class AliTPCROC;
 class AliTPCCalROC;
 class AliTPCRawStream;
 class AliRawReader;
-struct eventHeaderStruct;
 
+struct eventHeaderStruct;
 
 class AliTPCCalibPedestal : public TObject {
 
@@ -30,9 +31,9 @@ public:
   Bool_t ProcessEvent(AliRawReader    *rawReader);
   Bool_t ProcessEvent(eventHeaderStruct   *event);
 
-  Int_t Update(const Int_t isector, const Int_t iRow, const Int_t iPad,
-              const Int_t iTimeBin, const Float_t signal);
-  void Analyse();
+  Int_t  Update(const Int_t isector, const Int_t iRow, const Int_t iPad,
+               const Int_t iTimeBin, const Float_t signal);
+  void   Analyse();
   //
   AliTPCCalROC* GetCalRocPedestal (Int_t sector, Bool_t force=kFALSE);  // get calibration object - sector
   AliTPCCalROC* GetCalRocRMS(Int_t sector, Bool_t force=kFALSE);        // get calibration object - sector
@@ -42,6 +43,10 @@ public:
   TH2F* GetHistoPedestal  (Int_t sector, Bool_t force=kFALSE);          // get refernce histogram
   void  DumpToFile(const Char_t *filename, const Char_t *dir="", const Bool_t append=kFALSE);
   //
+  void  SetTimeAnalysis(Bool_t time = kTRUE);                  // Use ONLY in TPCPEDESTALda on LDC for one sector!
+  void  AnalyseTime(Int_t nevents);                            // Makes sense only in TPCPEDESTALda on LDC!
+  TArrayF **GetTimePedestals()  const { return fTimeSignal; }  // Get array with time dependent pedestals (for one sector!)
+  //
   Int_t GetFirstTimeBin() const { return fFirstTimeBin; }
   Int_t GetLastTimeBin()  const { return fLastTimeBin;  }
   Int_t GetAdcMin()       const { return fAdcMin;       }
@@ -50,40 +55,40 @@ public:
   void  SetRangeTime(Int_t tMin, Int_t tMax){ fFirstTimeBin=tMin; fLastTimeBin=tMax; }  // Set time bin range that is used for the pedestal calibration
   void  SetRangeAdc (Int_t aMin, Int_t aMax){ fAdcMin=aMin; fAdcMax=aMax; }  // Set adc range for the pedestal calibration
 
-  void  SetOldRCUformat(Bool_t format=kTRUE){ fOldRCUformat = format; }
+  void  SetOldRCUformat(Bool_t format=kTRUE) { fOldRCUformat = format; }
 
-  void Merge(AliTPCCalibPedestal *ped);
+  void  Merge(AliTPCCalibPedestal *ped);
 
-  Bool_t TestEvent();  //test the fast approach to fill histogram  - used for test purposes
+  Bool_t TestEvent();  // Test the fast approach to fill histogram - used for test purposes
 
 private:
+
   Int_t fFirstTimeBin;              //  First Time bin needed for analysis
   Int_t fLastTimeBin;               //  Last Time bin needed for analysis
-  
+
   Int_t fAdcMin;                    //  min adc channel of pedestal value
   Int_t fAdcMax;                    //  max adc channel of pedestal value
-  
+
   Bool_t  fOldRCUformat;            //! Should we use the old RCU format for data reading
+  Bool_t  fTimeAnalysis;            //! Should we use the time dependent analysis? ONLY ON LDC!
 
   AliTPCROC *fROC;                  //! ROC information
-  
+
   TObjArray fCalRocArrayPedestal;   //  Array of AliTPCCalROC class for Time0 calibration
   TObjArray fCalRocArrayRMS;        //  Array of AliTPCCalROC class for signal width calibration
-  
+
   TObjArray fHistoPedestalArray;    //  Calibration histograms for Pedestal distribution
-  
-  
-  
+
+  TArrayF **fTimeSignal;            //! Arrays which hold time dependent signals
+
   TH2F* GetHisto(Int_t sector, TObjArray *arr,
                 Int_t nbinsY, Float_t ymin, Float_t ymax,
                 Char_t *type, Bool_t force);
-    
+
   AliTPCCalROC* GetCalRoc(Int_t sector, TObjArray* arr, Bool_t force);
 
 public:
-
-
-  ClassDef(AliTPCCalibPedestal,1)  //Implementation of the TPC pedestal and noise calibration
+  ClassDef(AliTPCCalibPedestal, 2)  // Implementation of the TPC pedestal and noise calibration
 };
 
 
index 25670b1..6dcafb7 100644 (file)
  **************************************************************************/
 
 //-------------------------------------------------------------------------
-//  AliTPCmapper
-//  Origin: Christian.Lippmann@cern.ch
-//  
+//
+// AliTPCmapper
+// Authors: Christian.Lippmann@cern.ch, J.Wiechula@gsi.de
 // Class to map detector coordinates (row, pad, sector, ...) to
 // hardware coordinates (RCU, Branch, FEC, Altro, channel, Equipment ID, ...)
+// 
+// There are two different ways to number padrows:
+// 1) local padrow: for each ROC, 0 ... 62 for an IROC, 0 ... 95 for an OROC,
+// 2) global padrow: for each sector, from 0 ... 158.
+// If the global numbering is used, it is denoted by the variable name
+// globalpadrow in this class.
 //
-// Note: There are two different ways to number padrows:
-// 1) for each ROC, like 0 ... 62 for an IROC and 0 ... 95 for an OROC,
-// 2) for each sector, from 0 ... 158.
-// If the second numbering is used, it is denoted by the variable name
-// sectorpadrow in this class.
-//
-// Note: There are two different ways to number sectors:
+// There are two different ways to number sectors:
 // 1) Sectors contain one IROC and one OROC and are counted from 0 to 17 on
 //    each of the two sides (A=0 and C=1),
 // 2) ROCs are numbered from 0 to 71 where the ROCs 0 ... 35 are IROCS and
 //    ROCs 36 ... 71 are OROCs. A ROC is often named "sector" in aliroot,
 //    which can be very confusing!
+//
 //-------------------------------------------------------------------------
 
-//#include <stdio.h>
 #include <TMath.h>
 #include <TSystem.h>
 #include <TString.h>
@@ -43,6 +43,7 @@
 #include "AliTPCAltroMapping.h"
 #include "AliTPCROC.h"
 #include "AliLog.h"
+#include "AliDAQ.h"
 
 ClassImp(AliTPCmapper)
 
@@ -57,6 +58,7 @@ AliTPCmapper::AliTPCmapper() :
   fNpadrow(0),
   fNpadrowIROC(0),
   fNpadrowOROC(0),
+  fTpcDdlOffset(0),
   fROC(NULL)
 {
   // Constructor
@@ -89,6 +91,7 @@ AliTPCmapper::AliTPCmapper(const AliTPCmapper& mapper) :
   fNpadrow(mapper.fNpadrow),
   fNpadrowIROC(mapper.fNpadrowIROC),
   fNpadrowOROC(mapper.fNpadrowOROC),
+  fTpcDdlOffset(mapper.fTpcDdlOffset),
   fROC(mapper.fROC)
 {
   // Copy Constructor
@@ -115,6 +118,7 @@ AliTPCmapper& AliTPCmapper::operator = (const AliTPCmapper& mapper)
   fNpadrow = mapper.fNpadrow;
   fNpadrowIROC = mapper.fNpadrowIROC;
   fNpadrowOROC = mapper.fNpadrowOROC;
+  fTpcDdlOffset = mapper.fTpcDdlOffset;
 
   return *this;
 }
@@ -123,11 +127,11 @@ AliTPCmapper& AliTPCmapper::operator = (const AliTPCmapper& mapper)
 void AliTPCmapper::Init()
 {
   // Initialize all
-  fNside = 2;
-  fNsector = 18;
-  fNrcu = 6;
-  fNbranch = 2;
-  fNaltro = 8;
+  fNside    = 2;
+  fNsector  = 18;
+  fNrcu     = 6;
+  fNbranch  = 2;
+  fNaltro   = 8;
   fNchannel = 15;
 
   // Load and read mapping files. AliTPCAltroMapping contains the mapping for
@@ -149,6 +153,9 @@ void AliTPCmapper::Init()
   fNpadrowOROC = fROC->GetNRows(36);
   fNpadrow = fNpadrowIROC+fNpadrowOROC;
 
+  AliDAQ daq;
+  fTpcDdlOffset = daq.DdlIDOffset("TPC");
+
 }
 
 
@@ -157,25 +164,25 @@ Int_t AliTPCmapper::GetHWAddress(Int_t roc, Int_t padrow, Int_t pad) const
 {
   // Get the hardware address from pad coordinates for a given ROC
   Int_t patch = GetPatch(roc, padrow, pad);
-  if ( patch < 0 ) return -1;
+  if ( (patch >= fNrcu) || (patch < 0) ) return -1;
   return fMapping[patch]->GetHWAddress(padrow, pad, roc);
 }
 
 
 //_____________________________________________________________________________
-Int_t AliTPCmapper::GetHWAddressSector(Int_t sectorpadrow, Int_t pad) const
+Int_t AliTPCmapper::GetHWAddressSector(Int_t globalpadrow, Int_t pad) const
 {
   // Get the hardware address from pad coordinates
   Int_t patch = 0;
-  if ( sectorpadrow < fNpadrowIROC   ) {
-    patch = GetPatch(0,  sectorpadrow, pad);
-    return fMapping[patch]->GetHWAddress(sectorpadrow, pad, 0);
-  } else if ( sectorpadrow < fNpadrow ) {
-    patch = GetPatch(36, sectorpadrow - fNpadrowIROC, pad);
-    return fMapping[patch]->GetHWAddress(sectorpadrow - fNpadrowIROC,
+  if ( globalpadrow < fNpadrowIROC   ) {
+    patch = GetPatch(0,  globalpadrow, pad);
+    return fMapping[patch]->GetHWAddress(globalpadrow, pad, 0);
+  } else if ( globalpadrow < fNpadrow ) {
+    patch = GetPatch(36, globalpadrow - fNpadrowIROC, pad);
+    return fMapping[patch]->GetHWAddress(globalpadrow - fNpadrowIROC,
                                         pad, 36);
   } else {
-    AliWarning(Form("Padrow outside range (sectorpadrow %d) !", sectorpadrow));
+    AliWarning(Form("Padrow outside range (globalpadrow %d) !", globalpadrow));
     return -1;
   }
 }
@@ -244,23 +251,23 @@ Int_t AliTPCmapper::GetPatch(Int_t roc, Int_t padrow, Int_t pad) const
 
 
 //_____________________________________________________________________________
-Int_t AliTPCmapper::GetRcuSector(Int_t sectorpadrow, Int_t pad) const
+Int_t AliTPCmapper::GetRcuSector(Int_t globalpadrow, Int_t pad) const
 {
   // Get the patch (rcu) index from the pad coordinates for a sector
-  return GetPatchSector(sectorpadrow, pad);
+  return GetPatchSector(globalpadrow, pad);
 }
 
 
 //_____________________________________________________________________________
-Int_t AliTPCmapper::GetPatchSector(Int_t sectorpadrow, Int_t pad) const
+Int_t AliTPCmapper::GetPatchSector(Int_t globalpadrow, Int_t pad) const
 {
   // Get the patch (rcu) index from the pad coordinates for a sector
-  if ( sectorpadrow >= fNpadrow ) {
-    AliWarning(Form("Padrow outside range (sectorpadrow %d) !", sectorpadrow));
+  if ( globalpadrow >= fNpadrow ) {
+    AliWarning(Form("Padrow outside range (globalpadrow %d) !", globalpadrow));
     return -1;
   }
-  if ( sectorpadrow < fNpadrowIROC ) return GetPatch(0,  sectorpadrow, pad);
-  else                               return GetPatch(36, sectorpadrow-fNpadrowIROC, pad);
+  if ( globalpadrow < fNpadrowIROC ) return GetPatch(0,  globalpadrow, pad);
+  else                               return GetPatch(36, globalpadrow-fNpadrowIROC, pad);
 }
 
 
@@ -268,12 +275,16 @@ Int_t AliTPCmapper::GetPatchSector(Int_t sectorpadrow, Int_t pad) const
 Int_t AliTPCmapper::GetPadRow(Int_t patch, Int_t hwAddress) const
 {
   // Get Pad Row (for a ROC) from the hardware address
+  if ( (patch >= fNrcu) || (patch < 0) ) {
+    AliWarning(Form("Patch index outside range (patch %d) !", patch));
+    return -1;
+  }
   return fMapping[patch]->GetPadRow(hwAddress);
 }
 
 
 //_____________________________________________________________________________
-  Int_t AliTPCmapper::GetSectorPadRow(Int_t patch, Int_t hwAddress) const
+  Int_t AliTPCmapper::GetGlobalPadRow(Int_t patch, Int_t hwAddress) const
 {
   // Get Pad Row (for full sector) from the hardware address
   if ( patch < 2 ) return GetPadRow(patch, hwAddress);
@@ -285,6 +296,10 @@ Int_t AliTPCmapper::GetPadRow(Int_t patch, Int_t hwAddress) const
 Int_t AliTPCmapper::GetPad(Int_t patch, Int_t hwAddress) const
 {
   // Get Pad index from the hardware address
+  if ( (patch >= fNrcu) || (patch < 0) ) {
+    AliWarning(Form("Patch index outside range (patch %d) !", patch));
+    return -1;
+  }
   return fMapping[patch]->GetPad(hwAddress);
 }
 
@@ -305,7 +320,7 @@ Int_t AliTPCmapper::GetPadRow(Int_t patch, Int_t branch, Int_t fec, Int_t chip,
 
 
 //_____________________________________________________________________________
-Int_t AliTPCmapper::GetSectorPadRow(Int_t patch, Int_t branch, Int_t fec, Int_t chip,
+Int_t AliTPCmapper::GetGlobalPadRow(Int_t patch, Int_t branch, Int_t fec, Int_t chip,
                                    Int_t channel) const
 {
   // Get Pad Row (for full sector) from the hardware address
@@ -345,11 +360,11 @@ Int_t AliTPCmapper::GetBranch(Int_t roc, Int_t padrow, Int_t pad) const
 
 
 //_____________________________________________________________________________
-Int_t AliTPCmapper::GetBranchSector(Int_t sectorpadrow, Int_t pad) const
+Int_t AliTPCmapper::GetBranchSector(Int_t globalpadrow, Int_t pad) const
 {
-  // Get Branch from pad coordinates, where sectorpadrow is counted
+  // Get Branch from pad coordinates, where globalpadrow is counted
   // for a full sector (0 ... 158)
-  return DecodedHWAddressBranch(GetHWAddressSector(sectorpadrow, pad));
+  return DecodedHWAddressBranch(GetHWAddressSector(globalpadrow, pad));
 }
 
 
@@ -365,11 +380,11 @@ Int_t AliTPCmapper::GetFEChw(Int_t roc, Int_t padrow, Int_t pad) const
 
 
 //_____________________________________________________________________________
-Int_t AliTPCmapper::GetFEChwSector(Int_t sectorpadrow, Int_t pad) const
+Int_t AliTPCmapper::GetFEChwSector(Int_t globalpadrow, Int_t pad) const
 {
   // Get the FEC number in hardware numbering from pad coordinates, where 
-  // sectorpadrow is counted for a full sector (0 ... 158)
-  return DecodedHWAddressFECaddr(GetHWAddressSector(sectorpadrow, pad));
+  // globalpadrow is counted for a full sector (0 ... 158)
+  return DecodedHWAddressFECaddr(GetHWAddressSector(globalpadrow, pad));
 }
 
 
@@ -387,13 +402,13 @@ Int_t AliTPCmapper::GetFEC(Int_t roc, Int_t padrow, Int_t pad) const
 
 
 //_____________________________________________________________________________
-Int_t AliTPCmapper::GetFECSector(Int_t sectorpadrow, Int_t pad) const
+Int_t AliTPCmapper::GetFECSector(Int_t globalpadrow, Int_t pad) const
 {
-  // Get the FEC number in offline-oriented numbering. Sectorpadrow is
+  // Get the FEC number in offline-oriented numbering. globalpadrow is
   // counted for a full sector (0 ... 158)
-  Int_t patch  = GetPatchSector(sectorpadrow, pad);
-  Int_t fec    = DecodedHWAddressFECaddr(GetHWAddressSector(sectorpadrow, pad));
-  Int_t branch = DecodedHWAddressBranch(GetHWAddressSector(sectorpadrow, pad));
+  Int_t patch  = GetPatchSector(globalpadrow, pad);
+  Int_t fec    = DecodedHWAddressFECaddr(GetHWAddressSector(globalpadrow, pad));
+  Int_t branch = DecodedHWAddressBranch(GetHWAddressSector(globalpadrow, pad));
   if ( (fec < 0) || (branch < 0) || (patch < 0) ) return -1;
   return HwToOffline(patch, branch, fec);
 }
@@ -408,11 +423,11 @@ Int_t AliTPCmapper::GetChip(Int_t roc, Int_t padrow, Int_t pad) const
 
 
 //_____________________________________________________________________________
-Int_t AliTPCmapper::GetChipSector(Int_t sectorpadrow, Int_t pad) const
+Int_t AliTPCmapper::GetChipSector(Int_t globalpadrow, Int_t pad) const
 {
   // Get Chip (ALTRO) index (0 ... 7) from pad coordinates, where 
-  // sectorpadrow is counted for a full sector (0 ... 158)
-  return DecodedHWAddressChipaddr(GetHWAddressSector(sectorpadrow, pad));
+  // globalpadrow is counted for a full sector (0 ... 158)
+  return DecodedHWAddressChipaddr(GetHWAddressSector(globalpadrow, pad));
 }
 
 
@@ -425,11 +440,11 @@ Int_t AliTPCmapper::GetChannel(Int_t roc, Int_t padrow, Int_t pad) const
 
 
 //_____________________________________________________________________________
-Int_t AliTPCmapper::GetChannelSector(Int_t sectorpadrow, Int_t pad) const
+Int_t AliTPCmapper::GetChannelSector(Int_t globalpadrow, Int_t pad) const
 {
   // Get Channel index (0 ... 15) from pad coordinates, where 
-  // sectorpadrow is counted for a full sector (0 ... 158)
-  return DecodedHWAddressChanneladdr(GetHWAddressSector(sectorpadrow, pad));
+  // globalpadrow is counted for a full sector (0 ... 158)
+  return DecodedHWAddressChanneladdr(GetHWAddressSector(globalpadrow, pad));
 }
 
 
@@ -485,15 +500,15 @@ Int_t AliTPCmapper::GetNpads(Int_t roc, Int_t padrow) const{
 
 
 //______________________________________________________________
-Int_t AliTPCmapper::GetNpads(Int_t sectorpadrow) const{
-  // Get number of pads in padrow, where sectorpadrow is counted for a full sector (0 ... 158)
+Int_t AliTPCmapper::GetNpads(Int_t globalpadrow) const{
+  // Get number of pads in padrow, where globalpadrow is counted for a full sector (0 ... 158)
 
-  if ( sectorpadrow >= fNpadrow ) {
-    AliWarning(Form("Padrow outside range (sectorpadrow %d) !", sectorpadrow));
+  if ( globalpadrow >= fNpadrow ) {
+    AliWarning(Form("Padrow outside range (globalpadrow %d) !", globalpadrow));
     return -1;
   }
-  if ( sectorpadrow < fNpadrowIROC ) return GetNpads(0,  sectorpadrow);  // IROC
-  else  return GetNpads(36, sectorpadrow - fNpadrowIROC);                // OROC
+  if ( globalpadrow < fNpadrowIROC ) return GetNpads(0,  globalpadrow);  // IROC
+  else  return GetNpads(36, globalpadrow - fNpadrowIROC);                // OROC
 
   return -1;
 }
@@ -509,48 +524,48 @@ Int_t AliTPCmapper::GetNpadrows(Int_t roc) const
 
 //______________________________________________________________
 /*
-Double_t AliTPCmapper::GetPadXlocal(Int_t sectorpadrow) const
+Double_t AliTPCmapper::GetPadXlocal(Int_t globalpadrow) const
 {
-  // Get local x coordinate of pad, where sectorpadrow is counted for a full sector (0 ... 158)
+  // Get local x coordinate of pad, where globalpadrow is counted for a full sector (0 ... 158)
 
-  if ( sectorpadrow >= fNpadrow ) {
-    AliWarning(Form("Padrow outside range (sectorpadrow %d) !", sectorpadrow));
+  if ( globalpadrow >= fNpadrow ) {
+    AliWarning(Form("Padrow outside range (globalpadrow %d) !", globalpadrow));
     return -1.0;
   }
 
   //IROC
-  if ( sectorpadrow < fNpadrowIROC )
-    return (852.25 + 7.5*(Double_t)sectorpadrow)/10.; //divide by 10 to get cm
+  if ( globalpadrow < fNpadrowIROC )
+    return (852.25 + 7.5*(Double_t)globalpadrow)/10.; //divide by 10 to get cm
 
-  sectorpadrow -= fNpadrowIROC;
+  globalpadrow -= fNpadrowIROC;
 
-  if ( sectorpadrow < 64 ) //OROC inner part
-    return (10.* sectorpadrow + 1351.)/10.;         //divide by 10 to get cm
+  if ( globalpadrow < 64 ) //OROC inner part
+    return (10.* globalpadrow + 1351.)/10.;         //divide by 10 to get cm
 
   //OROC outer part
-  return (15.*(sectorpadrow - 64) + 1993.5)/10.;    //divide by 10 to get cm
+  return (15.*(globalpadrow - 64) + 1993.5)/10.;    //divide by 10 to get cm
 }
 */
 
 //______________________________________________________________
 /*
-Double_t AliTPCmapper::GetPadYlocal(Int_t sectorpadrow, Int_t pad) const
+Double_t AliTPCmapper::GetPadYlocal(Int_t globalpadrow, Int_t pad) const
 {
-  // Get local y coordinate of pad, where sectorpadrow is counted for a full sector (0 ... 158)
+  // Get local y coordinate of pad, where globalpadrow is counted for a full sector (0 ... 158)
 
-  if ( sectorpadrow >= fNpadrow ) {
-    AliWarning(Form("Padrow outside range (sectorpadrow %d) !", sectorpadrow));
+  if ( globalpadrow >= fNpadrow ) {
+    AliWarning(Form("Padrow outside range (globalpadrow %d) !", globalpadrow));
     return -1.0;
   }
 
-  Int_t padsInRow = GetNpads(sectorpadrow);
+  Int_t padsInRow = GetNpads(globalpadrow);
   if ( (padsInRow < 0) || (pad >= padsInRow) ) {
     AliWarning(Form("Pad index outside range (pad %d) !", pad));
     return -1.0;
   }
 
   //IROC
-  if ( sectorpadrow < fNpadrowIROC )
+  if ( globalpadrow < fNpadrowIROC )
     return (2.* padsInRow - 4.*pad - 2.)*1.e-1;  //divide by 10 to get cm
 
   //OROC
@@ -560,62 +575,62 @@ Double_t AliTPCmapper::GetPadYlocal(Int_t sectorpadrow, Int_t pad) const
 
 //______________________________________________________________
 /*
-Double_t AliTPCmapper::GetPadXglobal(Int_t sectorpadrow, Int_t pad, Int_t sector) const
+Double_t AliTPCmapper::GetPadXglobal(Int_t globalpadrow, Int_t pad, Int_t sector) const
 {
-  // Get global x coordinate of pad, where sectorpadrow is counted for a full sector (0 ... 158)
+  // Get global x coordinate of pad, where globalpadrow is counted for a full sector (0 ... 158)
 
-  if ( sectorpadrow >= fNpadrow ) {
-    AliWarning(Form("Padrow outside range (sectorpadrow %d) !", sectorpadrow));
+  if ( globalpadrow >= fNpadrow ) {
+    AliWarning(Form("Padrow outside range (globalpadrow %d) !", globalpadrow));
     return -1.0;
   }
 
-  Int_t padsInRow = GetNpads(sectorpadrow);
+  Int_t padsInRow = GetNpads(globalpadrow);
   if ( (padsInRow < 0) || (pad >= padsInRow) ) {
     AliWarning(Form("Pad index outside range (pad %d) !", pad));
     return -1.0;
   }
 
   Double_t angle = (Double_t)(( sector * 20. ) + 10. ) * TMath::DegToRad();
-  return GetPadXlocal(sectorpadrow) * TMath::Cos(angle) -
-    GetPadYlocal(sectorpadrow, pad) * TMath::Sin(angle);
+  return GetPadXlocal(globalpadrow) * TMath::Cos(angle) -
+    GetPadYlocal(globalpadrow, pad) * TMath::Sin(angle);
 }
 */
 
 //______________________________________________________________
 /*
-Double_t AliTPCmapper::GetPadYglobal(Int_t sectorpadrow, Int_t pad,Int_t sector) const
+Double_t AliTPCmapper::GetPadYglobal(Int_t globalpadrow, Int_t pad,Int_t sector) const
 {
-  // Get global y coordinate of pad, where sectorpadrow is counted for a full sector (0 ... 158)
+  // Get global y coordinate of pad, where globalpadrow is counted for a full sector (0 ... 158)
 
-  if ( sectorpadrow >= fNpadrow ) {
-    AliWarning(Form("Padrow outside range (sectorpadrow %d) !", sectorpadrow));
+  if ( globalpadrow >= fNpadrow ) {
+    AliWarning(Form("Padrow outside range (globalpadrow %d) !", globalpadrow));
     return -1.0;
   }
 
-  Int_t padsInRow = GetNpads(sectorpadrow);
+  Int_t padsInRow = GetNpads(globalpadrow);
   if ( (padsInRow < 0) || (pad >= padsInRow) ) {
     AliWarning(Form("Pad index outside range (pad %d) !", pad));
     return -1.0;
   }
 
   Double_t angle = (Double_t)(( sector * 20. ) + 10. ) * TMath::DegToRad();
-  return GetPadXlocal(sectorpadrow) * TMath::Sin(angle) +
-    GetPadYlocal(sectorpadrow, pad) * TMath::Cos(angle);
+  return GetPadXlocal(globalpadrow) * TMath::Sin(angle) +
+    GetPadYlocal(globalpadrow, pad) * TMath::Cos(angle);
 }
 */
 
 //______________________________________________________________
 /*
-Double_t AliTPCmapper::GetPadWidth(Int_t sectorpadrow) const
+Double_t AliTPCmapper::GetPadWidth(Int_t globalpadrow) const
 {
-  //  Get pad width, where sectorpadrow is counted for a full sector (0 ... 158)
+  //  Get pad width, where globalpadrow is counted for a full sector (0 ... 158)
 
-  if ( sectorpadrow >= fNpadrow ) {
-    AliWarning(Form("Padrow outside range (sectorpadrow %d) !", sectorpadrow));
+  if ( globalpadrow >= fNpadrow ) {
+    AliWarning(Form("Padrow outside range (globalpadrow %d) !", globalpadrow));
     return -1.0;
   }
 
-  if (sectorpadrow < fNpadrowIROC ) // IROC
+  if (globalpadrow < fNpadrowIROC ) // IROC
     return 0.4;
   return 0.6;
 }
@@ -623,17 +638,17 @@ Double_t AliTPCmapper::GetPadWidth(Int_t sectorpadrow) const
 
 //______________________________________________________________
 /*
-Double_t AliTPCmapper::GetPadLength(Int_t sectorpadrow) const
+Double_t AliTPCmapper::GetPadLength(Int_t globalpadrow) const
 {
-  // Get pad length, where sectorpadrow is counted for a full sector (0 ... 158)
+  // Get pad length, where globalpadrow is counted for a full sector (0 ... 158)
 
-  if ( sectorpadrow >= fNpadrow ) {
-    AliWarning(Form("Padrow outside range (sectorpadrow %d) !", sectorpadrow));
+  if ( globalpadrow >= fNpadrow ) {
+    AliWarning(Form("Padrow outside range (globalpadrow %d) !", globalpadrow));
     return -1.0;
   }
 
-  if ( sectorpadrow < fNpadrowIROC ) return  0.75;
-  if ( sectorpadrow < 127 )          return 1.0;
+  if ( globalpadrow < fNpadrowIROC ) return  0.75;
+  if ( globalpadrow < 127 )          return 1.0;
   return 1.5;
 }
 */
@@ -784,18 +799,18 @@ Int_t AliTPCmapper::GetEquipmentID(Int_t roc, Int_t padrow, Int_t pad) const
 
 
 //_____________________________________________________________________________
-Int_t AliTPCmapper::GetEquipmentIDsector(Int_t side, Int_t sector, Int_t sectorpadrow, Int_t pad) const
+Int_t AliTPCmapper::GetEquipmentIDsector(Int_t side, Int_t sector, Int_t globalpadrow, Int_t pad) const
 {
   // Get EqID from pad coordinate, where padrow is counted for a full sector (0 ... 158)
-  Int_t patch = GetPatchSector(sectorpadrow, pad);
+  Int_t patch = GetPatchSector(globalpadrow, pad);
   if ( patch < 0 ) return -1;
   Int_t roc = GetRocFromPatch(side, sector, patch);
   if ( roc < 0 ) return -1;
 
-  if ( sectorpadrow < fNpadrowIROC )
-    return GetEquipmentID(roc, sectorpadrow, pad);
+  if ( globalpadrow < fNpadrowIROC )
+    return GetEquipmentID(roc, globalpadrow, pad);
   else
-    return GetEquipmentID(roc, sectorpadrow-fNpadrowIROC, pad);
+    return GetEquipmentID(roc, globalpadrow-fNpadrowIROC, pad);
 }
 
 
@@ -811,7 +826,7 @@ Int_t AliTPCmapper::GetEquipmentIDfromPatch(Int_t side, Int_t sector, Int_t patc
   else            // OROC
     ddl = (roc-36)*4 + 36*2 + (patch-2);
   // Add offset. TPC has detectorID = 3
-  return (ddl+(3<<8));
+  return ddl+fTpcDdlOffset;
 }
 
 
@@ -821,7 +836,7 @@ Int_t AliTPCmapper::GetPatchFromEquipmentID(Int_t equipmentID) const
   // Get rcu (patch) index (0 ... 5) from equipment ID
   Int_t retval = 0;
 
-  if ( (equipmentID < (3<<8)) || (equipmentID > 983) ) {
+  if ( (equipmentID < fTpcDdlOffset) || (equipmentID > 983) ) {
     AliWarning(Form("Equipment ID (%d) outside range !", equipmentID));
     return -1;
   }
@@ -835,7 +850,7 @@ Int_t AliTPCmapper::GetPatchFromEquipmentID(Int_t equipmentID) const
 Int_t AliTPCmapper::GetSideFromEquipmentID(Int_t equipmentID) const
 {
   // Get side from Eq ID
-  if ( (equipmentID < (3<<8)) ) {
+  if ( equipmentID < fTpcDdlOffset ) {
     AliWarning(Form("Equipment ID (%d) outside range !", equipmentID));
     return -1;
   }
@@ -856,7 +871,7 @@ Int_t AliTPCmapper::GetSectorFromEquipmentID(Int_t equipmentID) const
   // Get sector index (0 ... 17) from equipment ID
   Int_t retval = 0;
 
-  if ( (equipmentID < (3<<8)) || (equipmentID > 983) ) {
+  if ( (equipmentID < fTpcDdlOffset) || (equipmentID > 983) ) {
     AliWarning(Form("Equipment ID (%d) outside range !", equipmentID));
     return -1;
   }
@@ -956,11 +971,11 @@ Int_t AliTPCmapper::GetRocFromPatch(Int_t side, Int_t sector, Int_t patch) const
 
 
 //_____________________________________________________________________________
-Int_t AliTPCmapper::GetRoc(Int_t side, Int_t sector, Int_t sectorpadrow, Int_t pad) const
+Int_t AliTPCmapper::GetRoc(Int_t side, Int_t sector, Int_t globalpadrow, Int_t pad) const
 {
   // Get Roc (0 ... 71) from side (0, 1), sector (0 ... 17) and pad coordinates
 
-  Int_t patch = GetPatchSector(sectorpadrow, pad);
+  Int_t patch = GetPatchSector(globalpadrow, pad);
   if ( patch < 0 ) return -1;
   return GetRocFromPatch(side, sector, patch);
 }
index fe068eb..e70720e 100644 (file)
@@ -3,6 +3,14 @@
 /* Copyright(c) 1998-2006, ALICE Experiment at CERN, All rights reserved. *
  * See cxx source for full Copyright notice                               */
 
+////////////////////////////////////////////////////////////////////////
+//
+// AliTPCmapper class
+// Class for all mapping functions (hardware coordinates <-> pad coordinates)
+// Author: Christian Lippmann
+//       
+/////////////////////////////////////////////////////////////////////////
+
 #include <TObject.h>
 
 class AliTPCAltroMapping;
@@ -23,30 +31,30 @@ public:
   // ALTRO mapping functions
   Int_t GetPad(Int_t patch, Int_t hwAddress) const;
   Int_t GetPad(Int_t patch, Int_t branch, Int_t fec, Int_t chip, Int_t channel) const;
+  Int_t GetPadRow(Int_t patch, Int_t hwAddress) const;
+  Int_t GetPadRow(Int_t patch, Int_t branch, Int_t fec, Int_t chip, Int_t channel) const;
 
   // ALTRO mapping functions on roc level (padrow = 0 ... kNpadrowIROC, kNpadrowOROC)
   Int_t GetHWAddress(Int_t roc, Int_t padrow, Int_t pad) const;
   Int_t GetRcu(Int_t roc, Int_t padrow, Int_t pad) const;
   Int_t GetPatch(Int_t roc, Int_t padrow, Int_t pad) const;
-  Int_t GetPadRow(Int_t roc, Int_t hwAddress) const;
-  Int_t GetPadRow(Int_t roc, Int_t branch, Int_t fec, Int_t chip, Int_t channel) const;
   Int_t GetBranch(Int_t roc, Int_t padrow, Int_t pad) const;
   Int_t GetFEChw(Int_t roc, Int_t padrow, Int_t pad) const;
   Int_t GetFEC(Int_t roc, Int_t padrow, Int_t pad) const;
   Int_t GetChip(Int_t roc, Int_t padrow, Int_t pad) const;
   Int_t GetChannel(Int_t roc, Int_t padrow, Int_t pad) const;
 
-  // ALTRO mapping functions on sector level (sectorpadrow = 0 ... kNpadrow)
-  Int_t GetSectorPadRow(Int_t patch, Int_t hwAddress) const;
-  Int_t GetSectorPadRow(Int_t patch, Int_t branch, Int_t fec, Int_t chip, Int_t channel) const;
-  Int_t GetHWAddressSector(Int_t sectorpadrow, Int_t pad) const;
-  Int_t GetRcuSector(Int_t sectorpadrow, Int_t pad) const;
-  Int_t GetPatchSector(Int_t sectorpadrow, Int_t pad) const;
-  Int_t GetBranchSector(Int_t sectorpadrow, Int_t pad) const;
-  Int_t GetFEChwSector(Int_t sectorpadrow, Int_t pad) const;
-  Int_t GetFECSector(Int_t sectorpadrow, Int_t pad) const;
-  Int_t GetChipSector(Int_t sectorpadrow, Int_t pad) const;
-  Int_t GetChannelSector(Int_t sectorpadrow, Int_t pad) const;
+  // ALTRO mapping functions on sector level (globalpadrow = 0 ... kNpadrow)
+  Int_t GetGlobalPadRow(Int_t patch, Int_t hwAddress) const;
+  Int_t GetGlobalPadRow(Int_t patch, Int_t branch, Int_t fec, Int_t chip, Int_t channel) const;
+  Int_t GetHWAddressSector(Int_t globalpadrow, Int_t pad) const;
+  Int_t GetRcuSector(Int_t globalpadrow, Int_t pad) const;
+  Int_t GetPatchSector(Int_t globalpadrow, Int_t pad) const;
+  Int_t GetBranchSector(Int_t globalpadrow, Int_t pad) const;
+  Int_t GetFEChwSector(Int_t globalpadrow, Int_t pad) const;
+  Int_t GetFECSector(Int_t globalpadrow, Int_t pad) const;
+  Int_t GetChipSector(Int_t globalpadrow, Int_t pad) const;
+  Int_t GetChannelSector(Int_t globalpadrow, Int_t pad) const;
 
   // Coding and decoding of hardware addresses
   Int_t CodeHWAddress(Int_t branch,  Int_t fec,  Int_t chip, Int_t channel) const;
@@ -57,15 +65,15 @@ public:
 
   // Pad Geometry on sector level (padrow = 0 ... kNpadrow)
   Int_t    GetNpads(Int_t roc, Int_t padrow) const;
-  Int_t    GetNpads(Int_t sectorpadrow) const;
+  Int_t    GetNpads(Int_t globalpadrow) const;
   Int_t    GetNpadrows(Int_t roc) const;
   /*
-  Double_t GetPadXlocal(Int_t sectorpadrow) const;
-  Double_t GetPadYlocal(Int_t sectorpadrow, Int_t pad) const;
-  Double_t GetPadXglobal(Int_t sectorpadrow, Int_t pad, Int_t sector) const;
-  Double_t GetPadYglobal(Int_t sectorpadrow, Int_t pad, Int_t sector) const;
-  Double_t GetPadWidth(Int_t sectorpadrow) const;
-  Double_t GetPadLength(Int_t sectorpadrow) const;
+  Double_t GetPadXlocal(Int_t globalpadrow) const;
+  Double_t GetPadYlocal(Int_t globalpadrow, Int_t pad) const;
+  Double_t GetPadXglobal(Int_t globalpadrow, Int_t pad, Int_t sector) const;
+  Double_t GetPadYglobal(Int_t globalpadrow, Int_t pad, Int_t sector) const;
+  Double_t GetPadWidth(Int_t globalpadrow) const;
+  Double_t GetPadLength(Int_t globalpadrow) const;
   */
 
   // Conversion between hardware FEC numbering and official numbering
@@ -75,12 +83,12 @@ public:
 
   // More mapping functions
   Int_t GetEquipmentID(Int_t roc, Int_t padrow, Int_t pad) const;
-  Int_t GetEquipmentIDsector(Int_t side, Int_t sector, Int_t sectorpadrow, Int_t pad) const;
+  Int_t GetEquipmentIDsector(Int_t side, Int_t sector, Int_t globalpadrow, Int_t pad) const;
   Int_t GetEquipmentIDfromPatch(Int_t side, Int_t sector, Int_t patch) const;
   Int_t GetSectorFromRoc(Int_t roc) const;
   Int_t GetSideFromRoc(Int_t roc) const;
   Int_t GetRocFromPatch(Int_t side, Int_t sector, Int_t patch) const;
-  Int_t GetRoc(Int_t side, Int_t sector, Int_t sectorpadrow, Int_t pad) const;
+  Int_t GetRoc(Int_t side, Int_t sector, Int_t globalpadrow, Int_t pad) const;
   Int_t GetSideFromEquipmentID(Int_t equipmentID) const;
   Int_t GetSectorFromEquipmentID(Int_t equipmentID) const;
   Int_t GetRocFromEquipmentID(Int_t equipmentID) const;
@@ -94,15 +102,17 @@ public:
 
  private:
 
-  Int_t fNside;
-  Int_t fNsector;
-  Int_t fNrcu;
-  Int_t fNbranch;
-  Int_t fNaltro;
-  Int_t fNchannel;
-  Int_t fNpadrow;
-  Int_t fNpadrowIROC;
-  Int_t fNpadrowOROC;
+  Int_t fNside;        // TPC has 2 sides
+  Int_t fNsector;      // TPC has 18 sectors
+  Int_t fNrcu;         // Sector has 6 RCUs
+  Int_t fNbranch;      // RCU has 2 branches
+  Int_t fNaltro;       // FEC has 8 ALTROs
+  Int_t fNchannel;     // ALTRO has 16 channels
+  Int_t fNpadrow;      // Sector has 159 padrows
+  Int_t fNpadrowIROC;  // IROC has 63 padrows
+  Int_t fNpadrowOROC;  // OROC has 96 padrows
+
+  Int_t fTpcDdlOffset; // DDL offset for TPC
 
   AliTPCAltroMapping *fMapping[6];    // The ALTRO mapping for each patch (rcu)
   AliTPCROC *fROC;                    // ROC object containing some relevant functions
index 68c64a2..948b4ad 100644 (file)
@@ -28,6 +28,7 @@ extern "C" {
 //Root includes
 //
 #include <TFile.h>
+#include <TArrayF.h>
 
 //
 //AliRoot includes
@@ -47,27 +48,29 @@ extern "C" {
 //
 #include "AliTPCCalibPedestal.h"
 
-
-
-
-/* Main routine
-      Arguments: list of DATE raw data files
+/*
+  Main routine, TPC pedestal detector algorithm to be run on TPC LDC
+  Arguments: list of DATE raw data files
 */
+
 int main(int argc, char **argv) {
+  //
+  // Main for TPC pedestal detector algorithm
+  //
+  Bool_t timeAnalysis = kTRUE;
 
   int i,status;
-  AliTPCCalibPedestal calibPedestal;   // pedestal and noise calibration
+  AliTPCCalibPedestal calibPedestal;           // pedestal and noise calibration
+  calibPedestal.SetTimeAnalysis(timeAnalysis); // pedestal(t) calibration
 
   if (argc<2) {
     printf("Wrong number of arguments\n");
     return -1;
   }
 
-
   /* log start of process */
   printf("TPC DA started - %s\n",__FILE__);
 
-
   /* declare monitoring program */
   status=monitorDeclareMp( __FILE__ );
   if (status!=0) {
@@ -75,10 +78,9 @@ int main(int argc, char **argv) {
     return -1;
   }
 
-
   /* loop over RAW data files */
   int nevents=0;
-  for(i=1;i<argc;i++) {
+  for ( i=1; i<argc; i++ ) {
 
     /* define data source : this is argument i */
     printf("Processing file %s\n", argv[i]);
@@ -89,7 +91,7 @@ int main(int argc, char **argv) {
     }
 
     /* read until EOF */
-    for(;;) {
+    for ( ; ; ) {
       struct eventHeaderStruct *event;
 
       /* check shutdown condition */
@@ -98,19 +100,23 @@ int main(int argc, char **argv) {
       /* get next event (blocking call until timeout) */
       status=monitorGetEventDynamic((void **)&event);
       if (status==MON_ERR_EOF) {
-        printf ("End of File %d detected\n",i);
-        break; /* end of monitoring file has been reached */
+       printf ("End of File %d (%s) detected\n", i, argv[i]);
+       break; /* end of monitoring file has been reached */
       }
-
       if (status!=0) {
-        printf("monitorGetEventDynamic() failed : %s\n",monitorDecodeError(status));
-        break;
+       printf("monitorGetEventDynamic() failed : %s\n",monitorDecodeError(status));
+       break;
       }
 
+      /* skip start/end of run events */
+      if ( (event->eventType != physicsEvent) && (event->eventType != calibrationEvent) )
+       continue;
+
       /* retry if got no event */
       if (event==NULL) {
-        continue;
+       continue;
       }
+
       nevents++;
 
       //  Pedestal calibration
@@ -124,41 +130,92 @@ int main(int argc, char **argv) {
   }
 
   calibPedestal.Analyse(); 
-  printf ("%d events processed\n",nevents);
+  calibPedestal.AnalyseTime(nevents); 
+  printf ("%d physics/calibration events processed\n",nevents);
 
-  TFile * fileTPC = new TFile (RESULT_FILE,"recreate");
+  TFile *fileTPC = new TFile(RESULT_FILE, "recreate");
   calibPedestal.Write("calibPedestal");
   delete fileTPC;
   printf("Wrote %s\n",RESULT_FILE);
 
-  // Prepare files for local ALTRO configuration through DDL
-  AliTPCmapper mapping;
+  //
+  // Now prepare ASCII files for local ALTRO configuration through DDL
+  //
 
-  ofstream out;
+  ofstream pedfile;
+  ofstream noisefile;
+  ofstream pedmemfile;
   char filename[255];
-  sprintf(filename,"Pedestals.data");
-  out.open(filename);
+  sprintf(filename,"tpcPedestals.data");
+  pedfile.open(filename);
+  sprintf(filename,"tpcNoise.data");
+  noisefile.open(filename);
+  sprintf(filename,"tpcPedestalMem.data");
+  pedmemfile.open(filename);
+
+  TArrayF **timePed = calibPedestal.GetTimePedestals();
+  AliTPCmapper mapping;
 
-  Int_t ctr = 0;
+  Int_t ctr_channel = 0;
+  Int_t ctr_altro = 0;
+  Int_t ctr_pattern = 0;
 
-  out << 10 << endl;  // PEDESTALS
-  for ( int roc = 0; roc <= 71; roc++ ) {
-    if ( !calibPedestal.GetCalRocPedestal(roc) ) continue;
-    Int_t side = mapping.GetSideFromRoc(roc);
-    Int_t sec  = mapping.GetSectorFromRoc(roc);
-    printf("**Analysing ROC %d (side %d, sector %d) ...\n", roc, side, sec);
-    for ( int row = 0; row < mapping.GetNpadrows(roc); row++ ) {
-      for ( int pad = 0; pad < mapping.GetNpads(roc, row); pad++ ) {
-       Int_t rcu   = mapping.GetRcu(roc, row, pad);
-       Int_t hwadd = mapping.GetHWAddress(roc, row, pad);
-       Float_t ped   = calibPedestal.GetCalRocPedestal(roc)->GetValue(row,pad);
-       out << ctr << "\t" << side << "\t" << sec << "\t" << rcu << "\t" << hwadd << "\t" << ped << std::endl;
-       ctr++;
-      }
-    }
-  }
+  pedfile    << 10 << std::endl; // PEDESTALS per channel
+  noisefile  << 11 << std::endl; // NOISE per altro
+  pedmemfile << 12 << std::endl; // PEDESTALs per time bin
 
-  out.close();
+  for ( Int_t roc = 0; roc < 72; roc++ ) {
+    if ( !calibPedestal.GetCalRocPedestal(roc) ) continue;
+    Int_t side   = mapping.GetSideFromRoc(roc);
+    Int_t sector = mapping.GetSectorFromRoc(roc);
+    //printf("Analysing ROC %d (side %d, sector %d) ...\n", roc, side, sector);
+    Int_t nru = mapping.IsIROC(roc) ? 2 : 4;
+    for ( int rcu = 0; rcu < nru; rcu++ ) {
+      Int_t patch = mapping.IsIROC(roc) ? rcu : rcu+2;
+      for ( int branch = 0; branch < 2; branch++ ) {
+       for ( int fec = 0; fec < mapping.GetNfec(patch, branch); fec++ ) {
+         for ( int altro = 0; altro < 8; altro++ ) {
+           Float_t rms = 0.;
+           Float_t ctr = 0.;
+           for ( int channel = 0; channel < 16; channel++ ) {
+             Int_t hwadd = mapping.CodeHWAddress(branch, fec, altro, channel);
+             Int_t row   = mapping.GetPadRow(patch, hwadd);
+             Int_t pad   = mapping.GetPad(patch, hwadd);
+             Float_t ped = calibPedestal.GetCalRocPedestal(roc)->GetValue(row,pad);
+             // fixed pedestal
+             if ( ped > 1.e-10 ) {
+               pedfile << ctr_channel << "\t" << side << "\t" << sector << "\t" << patch << "\t" << hwadd << "\t" << ped << std::endl;
+               ctr_channel++;
+             }
+             // pedestal(t)
+             if ( timePed && fabs(timePed[row][pad].GetSum()) > 1e-10 ) {
+               pedmemfile << ctr_pattern << "\t" << side << "\t" << sector << "\t" << patch << "\t" << hwadd;
+               for ( Int_t timebin = 0; timebin < 1024; timebin++ )
+                 pedmemfile << "\t" << timePed[row][pad].At(timebin);
+               pedmemfile << std::endl;
+               ctr_pattern++;
+             }
+             // rms=noise
+             Float_t rms2 = calibPedestal.GetCalRocRMS(roc)->GetValue(row,pad);
+             if ( rms2 > 1.e-10 ) { rms += rms2; ctr += 1.; }
+           } // end channel for loop
+           // noise data (rms) averaged over all channels in this ALTRO.
+           Int_t hwadd = mapping.CodeHWAddress(branch, fec, altro, 0);
+           if ( ctr > 1.e-10 ) {
+             noisefile << ctr_altro << "\t" << side << "\t" << sector << "\t" << patch << "\t" << hwadd << "\t" << rms/ctr << std::endl;
+             ctr_altro++;
+           }
+         } // end altro for loop
+       } // end fec for loop
+      } // end branch for loop
+    } // end rcu for loop
+  } // end roc loop
+
+  pedfile.close();
+  noisefile.close();
+  pedmemfile.close();
+
+  printf("Wrote ASCII files\n");
 
   return status;
 }