Using fast raw stream as option (Jens, Per-Thomas)
authormarian <marian@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 4 Dec 2007 09:42:01 +0000 (09:42 +0000)
committermarian <marian@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 4 Dec 2007 09:42:01 +0000 (09:42 +0000)
TPC/AliTPCCalibCE.cxx
TPC/AliTPCCalibCE.h
TPC/AliTPCCalibPedestal.cxx
TPC/AliTPCCalibPedestal.h
TPC/AliTPCCalibPulser.cxx
TPC/AliTPCCalibPulser.h
TPC/AliTPCRawStreamFast.cxx
TPC/AliTPCRawStreamFast.h

index b12808b..d0b1202 100644 (file)
@@ -280,6 +280,7 @@ END_HTML */
 #include "AliRawReaderDate.h"
 #include "AliRawEventHeaderBase.h"
 #include "AliTPCRawStream.h"
+#include "AliTPCRawStreamFast.h"
 #include "AliTPCcalibDB.h"
 #include "AliTPCCalROC.h"
 #include "AliTPCCalPad.h"
@@ -831,8 +832,8 @@ void AliTPCCalibCE::EndEvent()
     AliTPCCalROC *calOroc=new AliTPCCalROC(36);
 
     //find mean time0 offset for side A and C
-    Double_t time0Side[2];       //time0 for side A:0 and C:0
-    Double_t time0SideCount[2];  //time0 counter for side A:0 and C:0
+    Double_t time0Side[2];       //time0 for side A:0 and C:1
+    Double_t time0SideCount[2];  //time0 counter for side A:0 and C:1
     time0Side[0]=0;time0Side[1]=0;time0SideCount[0]=0;time0SideCount[1]=0;
     for ( Int_t iSec = 0; iSec<72; ++iSec ){
        time0Side[(iSec/18)%2] += fVTime0Offset.GetMatrixArray()[iSec];
@@ -1032,6 +1033,58 @@ void AliTPCCalibCE::EndEvent()
     delete calOroc;
 }
 //_____________________________________________________________________
+Bool_t AliTPCCalibCE::ProcessEventFast(AliTPCRawStreamFast *rawStreamFast)
+{
+  //
+  // Event Processing loop - AliTPCRawStreamFast
+  //
+  ResetEvent();
+  Bool_t withInput = kFALSE;
+  while ( rawStreamFast->NextDDL() ){
+      while ( rawStreamFast->NextChannel() ){
+         Int_t isector  = rawStreamFast->GetSector();                       //  current sector
+         Int_t iRow     = rawStreamFast->GetRow();                          //  current row
+         Int_t iPad     = rawStreamFast->GetPad();                          //  current pad
+         Int_t startTbin = (Int_t)rawStreamFast->GetStartTimeBin();
+          Int_t endTbin = (Int_t)rawStreamFast->GetEndTimeBin();
+
+         while ( rawStreamFast->NextBunch() ){
+             for (Int_t iTimeBin = startTbin; iTimeBin < endTbin; iTimeBin++){
+                 Float_t signal=(Float_t)rawStreamFast->GetSignals()[iTimeBin-startTbin];
+                 Update(isector,iRow,iPad,iTimeBin+1,signal);
+                 withInput = kTRUE;
+             }
+         }
+      }
+  }
+  if (withInput){
+      EndEvent();
+  }
+  return withInput;
+}
+//_____________________________________________________________________
+Bool_t AliTPCCalibCE::ProcessEventFast(AliRawReader *rawReader)
+{
+  //
+  //  Event processing loop using the fast raw stream algorithm- AliRawReader
+  //
+
+  //printf("ProcessEventFast - raw reader\n");
+
+  AliRawEventHeaderBase* eventHeader = (AliRawEventHeaderBase*)rawReader->GetEventHeader();
+  if (eventHeader){
+      fTimeStamp   = eventHeader->Get("Timestamp");
+      fRunNumber = eventHeader->Get("RunNb");
+  }
+  fEventId = *rawReader->GetEventId();
+
+  AliTPCRawStreamFast *rawStreamFast = new AliTPCRawStreamFast(rawReader);
+  Bool_t res=ProcessEventFast(rawStreamFast);
+  delete rawStreamFast;
+  return res;
+
+}
+//_____________________________________________________________________
 Bool_t AliTPCCalibCE::ProcessEvent(AliTPCRawStream *rawStream)
 {
   //
index 18635e5..75aca8e 100644 (file)
@@ -21,6 +21,7 @@ class AliTPCCalROC;
 class AliTPCParam;
 class AliRawReader;
 class AliTPCRawStream;
+class AliTPCRawStreamFast;
 class TGraph;
 struct eventHeaderStruct;
 
@@ -33,6 +34,9 @@ public:
 
     AliTPCCalibCE& operator = (const  AliTPCCalibCE &source);
 
+    Bool_t ProcessEventFast(AliTPCRawStreamFast *rawStreamFast);
+    Bool_t ProcessEventFast(AliRawReader            *rawReader);
+
 
     Bool_t ProcessEvent(AliTPCRawStream *rawStream);
     Bool_t ProcessEvent(AliRawReader    *rawReader);
index 5c3aa42..72ffa0e 100644 (file)
@@ -31,6 +31,7 @@
 #include "AliRawReaderRoot.h"
 #include "AliRawReaderDate.h"
 #include "AliTPCRawStream.h"
+#include "AliTPCRawStreamFast.h"
 #include "AliTPCCalROC.h"
 #include "AliTPCROC.h"
 #include "AliMathBase.h"
@@ -207,7 +208,6 @@ AliTPCCalibPedestal::AliTPCCalibPedestal() : /*FOLD00*/
   fOldRCUformat(kTRUE),
   fTimeAnalysis(kFALSE),
   fROC(AliTPCROC::Instance()),
-  fMapping(NULL),
   fCalRocArrayPedestal(72),
   fCalRocArrayRMS(72),
   fHistoPedestalArray(72),
@@ -229,7 +229,6 @@ AliTPCCalibPedestal::AliTPCCalibPedestal(const AliTPCCalibPedestal &ped) : /*FOL
   fOldRCUformat(ped.fOldRCUformat),
   fTimeAnalysis(ped.fTimeAnalysis),
   fROC(AliTPCROC::Instance()),
-  fMapping(NULL),
   fCalRocArrayPedestal(72),
   fCalRocArrayRMS(72),
   fHistoPedestalArray(72),
@@ -287,9 +286,6 @@ AliTPCCalibPedestal::~AliTPCCalibPedestal() /*FOLD00*/
     delete [] fTimeSignal;
     fTimeSignal = 0;
   }
-
-  // do not delete fMapping, because we do not own it.
-
 }
 
 
@@ -349,7 +345,7 @@ Int_t AliTPCCalibPedestal::Update(const Int_t icsector, /*FOLD00*/
 
   Int_t iChannel  = fROC->GetRowIndexes(icsector)[icRow]+icPad; //  global pad position in sector
 
-  // fast filling method
+  // 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);
@@ -358,8 +354,47 @@ Int_t AliTPCCalibPedestal::Update(const Int_t icsector, /*FOLD00*/
 
   return 0;
 }
+//_____________________________________________________________________
+Bool_t AliTPCCalibPedestal::ProcessEventFast(AliTPCRawStreamFast *rawStreamFast)
+{
+  //
+  // Event Processing loop - AliTPCRawStream
+  //
+  Bool_t withInput = kFALSE;
 
+  while ( rawStreamFast->NextDDL() ){
+      while ( rawStreamFast->NextChannel() ){
+         Int_t isector  = rawStreamFast->GetSector();                       //  current sector
+         Int_t iRow     = rawStreamFast->GetRow();                          //  current row
+         Int_t iPad     = rawStreamFast->GetPad();                          //  current pad
+         Int_t startTbin = (Int_t)rawStreamFast->GetStartTimeBin();
+          Int_t endTbin = (Int_t)rawStreamFast->GetEndTimeBin();
+
+         while ( rawStreamFast->NextBunch() ){
+             for (Int_t iTimeBin = startTbin; iTimeBin < endTbin; iTimeBin++){
+                 Float_t signal=(Float_t)rawStreamFast->GetSignals()[iTimeBin-startTbin];
+                 Update(isector,iRow,iPad,iTimeBin+1,signal);
+                 withInput = kTRUE;
+             }
+         }
+      }
+  }
 
+  return withInput;
+}
+//_____________________________________________________________________
+Bool_t AliTPCCalibPedestal::ProcessEventFast(AliRawReader *rawReader)
+{
+  //
+  //  Event processing loop - AliRawReader
+  //
+ printf("ProcessEventFast - raw reader\n");
+
+  AliTPCRawStreamFast *rawStreamFast = new AliTPCRawStreamFast(rawReader);
+  Bool_t res=ProcessEventFast(rawStreamFast);
+  delete rawStreamFast;
+  return res;
+}
 //_____________________________________________________________________
 Bool_t AliTPCCalibPedestal::ProcessEvent(AliTPCRawStream *rawStream)
 {
@@ -372,7 +407,6 @@ Bool_t AliTPCCalibPedestal::ProcessEvent(AliTPCRawStream *rawStream)
   Bool_t withInput = kFALSE;
 
   while (rawStream->Next()) {
-
     Int_t iSector  = rawStream->GetSector();      //  current ROC
     Int_t iRow     = rawStream->GetRow();         //  current row
     Int_t iPad     = rawStream->GetPad();         //  current pad
@@ -382,11 +416,8 @@ Bool_t AliTPCCalibPedestal::ProcessEvent(AliTPCRawStream *rawStream)
     Update(iSector,iRow,iPad,iTimeBin,signal);
     withInput = kTRUE;
   }
-
   return withInput;
 }
-
-
 //_____________________________________________________________________
 Bool_t AliTPCCalibPedestal::ProcessEvent(AliRawReader *rawReader)
 {
@@ -394,8 +425,7 @@ Bool_t AliTPCCalibPedestal::ProcessEvent(AliRawReader *rawReader)
   //  Event processing loop - AliRawReader
   //
 
-  // if fMapping is NULL the rawstream will crate its own mapping
-  AliTPCRawStream rawStream(rawReader, (AliAltroMapping**)fMapping);
+  AliTPCRawStream rawStream(rawReader);
   rawReader->Select("TPC");
   return ProcessEvent(&rawStream);
 }
@@ -442,8 +472,8 @@ Bool_t AliTPCCalibPedestal::TestEvent() /*FOLD00*/
 
 //_____________________________________________________________________
 TH2F* AliTPCCalibPedestal::GetHisto(Int_t sector, TObjArray *arr, /*FOLD00*/
-                                   Int_t nbinsY, Float_t ymin, Float_t ymax,
-                                   Char_t *type, Bool_t force)
+                                 Int_t nbinsY, Float_t ymin, Float_t ymax,
+                                 Char_t *type, Bool_t force)
 {
     //
     // return pointer to Q histogram
index 253d242..afe17ff 100644 (file)
@@ -14,8 +14,8 @@ class TTreeSRedirector;
 class AliTPCROC;
 class AliTPCCalROC;
 class AliTPCRawStream;
+class AliTPCRawStreamFast;
 class AliRawReader;
-class AliTPCAltroMapping;
 
 struct eventHeaderStruct;
 
@@ -28,6 +28,9 @@ public:
 
   AliTPCCalibPedestal& operator = (const  AliTPCCalibPedestal &source);
 
+  Bool_t ProcessEventFast(AliTPCRawStreamFast *rawStreamFast);
+  Bool_t ProcessEventFast(AliRawReader            *rawReader);
+
   Bool_t ProcessEvent(AliTPCRawStream *rawStream);
   Bool_t ProcessEvent(AliRawReader    *rawReader);
   Bool_t ProcessEvent(eventHeaderStruct   *event);
@@ -36,9 +39,6 @@ public:
                const Int_t iTimeBin, const Float_t signal);
   void   Analyse();
   //
-  AliTPCAltroMapping **GetAltroMapping() { return fMapping; };
-  void  SetAltroMapping(AliTPCAltroMapping **mapp) { fMapping = mapp; };
-  //
   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
   const TObjArray* GetCalPadPedestal (){return &fCalRocArrayPedestal;}  // get calibration object
@@ -77,7 +77,6 @@ private:
   Bool_t  fTimeAnalysis;            //! Should we use the time dependent analysis? ONLY ON LDC!
 
   AliTPCROC *fROC;                  //! ROC information
-  AliTPCAltroMapping **fMapping;    //! Altro Mapping
 
   TObjArray fCalRocArrayPedestal;   //  Array of AliTPCCalROC class for Time0 calibration
   TObjArray fCalRocArrayRMS;        //  Array of AliTPCCalROC class for signal width calibration
@@ -93,7 +92,7 @@ private:
   AliTPCCalROC* GetCalRoc(Int_t sector, TObjArray* arr, Bool_t force);
 
 public:
-  ClassDef(AliTPCCalibPedestal, 3)  // Implementation of the TPC pedestal and noise calibration
+  ClassDef(AliTPCCalibPedestal, 2)  // Implementation of the TPC pedestal and noise calibration
 };
 
 
index 1c88353..706b6bf 100644 (file)
 #include "AliRawReaderRoot.h"
 #include "AliRawReaderDate.h"
 #include "AliTPCRawStream.h"
+#include "AliTPCRawStreamFast.h"
 #include "AliTPCCalROC.h"
 #include "AliTPCCalPad.h"
 #include "AliTPCROC.h"
@@ -641,10 +642,51 @@ void AliTPCCalibPulser::EndEvent()
                delete h1;
            }
            //Debug end
-
        }
     }
+}
+//_____________________________________________________________________
+Bool_t AliTPCCalibPulser::ProcessEventFast(AliTPCRawStreamFast *rawStreamFast)
+{
+  //
+  // Event Processing loop - AliTPCRawStream
+  //
+  ResetEvent();
 
+  Bool_t withInput = kFALSE;
+
+  while ( rawStreamFast->NextDDL() ){
+      while ( rawStreamFast->NextChannel() ){
+         Int_t isector  = rawStreamFast->GetSector();                       //  current sector
+         Int_t iRow     = rawStreamFast->GetRow();                          //  current row
+         Int_t iPad     = rawStreamFast->GetPad();                          //  current pad
+         Int_t startTbin = (Int_t)rawStreamFast->GetStartTimeBin();
+          Int_t endTbin = (Int_t)rawStreamFast->GetEndTimeBin();
+
+         while ( rawStreamFast->NextBunch() ){
+             for (Int_t iTimeBin = startTbin; iTimeBin < endTbin; iTimeBin++){
+                 Float_t signal=(Float_t)rawStreamFast->GetSignals()[iTimeBin-startTbin];
+                 Update(isector,iRow,iPad,iTimeBin+1,signal);
+                 withInput = kTRUE;
+             }
+         }
+      }
+  }
+  if (withInput){
+      EndEvent();
+  }
+  return withInput;
+}
+//_____________________________________________________________________
+Bool_t AliTPCCalibPulser::ProcessEventFast(AliRawReader *rawReader)
+{
+  //
+  //  Event processing loop - AliRawReader
+  //
+  AliTPCRawStreamFast *rawStreamFast = new AliTPCRawStreamFast(rawReader);
+  Bool_t res=ProcessEventFast(rawStreamFast);
+  delete rawStreamFast;
+  return res;
 }
 //_____________________________________________________________________
 Bool_t AliTPCCalibPulser::ProcessEvent(AliTPCRawStream *rawStream)
@@ -660,7 +702,6 @@ Bool_t AliTPCCalibPulser::ProcessEvent(AliTPCRawStream *rawStream)
   Bool_t withInput = kFALSE;
 
   while (rawStream->Next()) {
-
       Int_t isector  = rawStream->GetSector();                       //  current sector
       Int_t iRow     = rawStream->GetRow();                          //  current row
       Int_t iPad     = rawStream->GetPad();                          //  current pad
@@ -670,11 +711,9 @@ Bool_t AliTPCCalibPulser::ProcessEvent(AliTPCRawStream *rawStream)
       Update(isector,iRow,iPad,iTimeBin,signal);
       withInput = kTRUE;
   }
-
   if (withInput){
       EndEvent();
   }
-
   return withInput;
 }
 //_____________________________________________________________________
@@ -998,17 +1037,14 @@ void AliTPCCalibPulser::Analyse()
 
        for (UInt_t iChannel=0; iChannel<nChannels; ++iChannel){
 
-
            Float_t cogTime0 = -1000;
            Float_t cogQ     = -1000;
            Float_t cogRMS   = -1000;
             Float_t cogOut   = 0;
 
-
            Int_t offsetQ = (fNbinsQ+2)*(iChannel+1)+1;
            Int_t offsetT0 = (fNbinsT0+2)*(iChannel+1)+1;
            Int_t offsetRMS = (fNbinsRMS+2)*(iChannel+1)+1;
-
 /*
            AliMathBase::FitGaus(arrayhQ+offsetQ,fNbinsQ,fXminQ,fXmaxQ,&paramQ,&dummy);
            AliMathBase::FitGaus(arrayhT0+offsetT0,fNbinsT0,fXminT0,fXmaxT0,&paramT0,&dummy);
@@ -1021,8 +1057,6 @@ void AliTPCCalibPulser::Analyse()
            cogTime0 = AliMathBase::GetCOG(arrayhT0+offsetT0,fNbinsT0,fXminT0,fXmaxT0);
             cogRMS   = AliMathBase::GetCOG(arrayhRMS+offsetRMS,fNbinsRMS,fXminRMS,fXmaxRMS);
 
-
-
            /*
            if ( (cogQ < ??) && (cogTime0 > ??) && (cogTime0<??) && ( cogRMS>??) ){
                cogOut = 1;
@@ -1062,9 +1096,7 @@ void AliTPCCalibPulser::Analyse()
                    "\n";
            }
            //! debug
-
        }
-
     }
     delete fDebugStreamer;
     fDebugStreamer = 0x0;
index bc2663a..cc3aeef 100644 (file)
@@ -10,7 +10,7 @@
 /////////////////////////////////////////////////////////////////////////////////////////
 
 #include <TVectorT.h>
-#include <TObjArray.h>
+class TObjArray;
 class TH2S;
 class TTreeSRedirector;
 class AliTPCCalPad;
@@ -19,6 +19,7 @@ class AliTPCCalROC;
 class AliTPCParam;
 class AliRawReader;
 class AliTPCRawStream;
+class AliTPCRawStreamFast;
 struct eventHeaderStruct;
 
 class AliTPCCalibPulser : public TObject {
@@ -30,6 +31,9 @@ public:
 
     AliTPCCalibPulser& operator = (const  AliTPCCalibPulser &source);
 
+    Bool_t ProcessEventFast(AliTPCRawStreamFast *rawStreamFast);
+    Bool_t ProcessEventFast(AliRawReader            *rawReader);
+
 
     Bool_t ProcessEvent(AliTPCRawStream *rawStream);
     Bool_t ProcessEvent(AliRawReader    *rawReader);
index ae7210c..f72a7d6 100644 (file)
@@ -20,9 +20,8 @@
 /// This class provides access to TPC digits in raw data.
 ///
 /// It loops over all TPC digits in the raw data given by the AliRawReader.
-/// The Next method goes to the next digit. If there are no digits left
+/// The NextChannel method loads the data for the next pad. If there is no pad left
 /// it returns kFALSE.
-/// Several getters provide information about the current digit.
 ///
 ///////////////////////////////////////////////////////////////////////////////
 
@@ -36,7 +35,7 @@
 ClassImp(AliTPCRawStreamFast)
 
 //_____________________________________________________________________________
-AliTPCRawStreamFast::AliTPCRawStreamFast(AliRawReader* rawReader) :
+AliTPCRawStreamFast::AliTPCRawStreamFast(AliRawReader* rawReader, AliAltroMapping **mapping) :
   AliAltroRawStreamFast(rawReader),
   fSector(-1),
   fPrevSector(-1),
@@ -50,53 +49,25 @@ AliTPCRawStreamFast::AliTPCRawStreamFast(AliRawReader* rawReader) :
 
   SelectRawData("TPC");
 
-  TString path = gSystem->Getenv("ALICE_ROOT");
-  path += "/TPC/mapping/Patch";
-  TString path2;
-  for(Int_t i = 0; i < 6; i++) {
-    path2 = path;
-    path2 += i;
-    path2 += ".data";
-    fMapping[i] = new AliTPCAltroMapping(path2.Data());
+  if (mapping == NULL) {
+    TString path = gSystem->Getenv("ALICE_ROOT");
+    path += "/TPC/mapping/Patch";
+    TString path2;
+    for(Int_t i = 0; i < 6; i++) {
+      path2 = path;
+      path2 += i;
+      path2 += ".data";
+      fMapping[i] = new AliTPCAltroMapping(path2.Data());
+    }
+  }
+  else {
+    for(Int_t i = 0; i < 6; i++)
+      fMapping[i] = mapping[i];
   }
 
-  //fNoAltroMapping = kFALSE;
-}
-/*
-//_____________________________________________________________________________
-AliTPCRawStreamFast::AliTPCRawStreamFast(const AliTPCRawStreamFast& stream) :
-  AliAltroRawStreamFast(stream),
-  fSector(stream.fSector),
-  fPrevSector(stream.fPrevSector),
-  fRow(stream.fRow),
-  fPrevRow(stream.fPrevRow),
-  fPad(stream.fPad),
-  fPrevPad(stream.fPrevPad),
-  fIsMapOwner(kFALSE)
-{
-  for(Int_t i = 0; i < 6; i++) fMapping[i] = stream.fMapping[i];
-}
-
-//_____________________________________________________________________________
-AliTPCRawStreamFast& AliTPCRawStreamFast::operator = (const AliTPCRawStreamFast& stream)
-{
-  if(&stream == this) return *this;
-
-  ((AliAltroRawStreamFast *)this)->operator=(stream);
-
-  fSector = stream.fSector;
-  fPrevSector = stream.fPrevSector;
-  fRow = stream.fRow;
-  fPrevRow = stream.fPrevRow;
-  fPad = stream.fPad;
-  fPrevPad = stream.fPrevPad;
-  fIsMapOwner = kFALSE;
-
-  for(Int_t i = 0; i < 6; i++) fMapping[i] = stream.fMapping[i];
 
-  return *this;
+  //fNoAltroMapping = kFALSE;
 }
-*/
 //_____________________________________________________________________________
 AliTPCRawStreamFast::~AliTPCRawStreamFast()
 {
index 5b25d99..0e966f4 100644 (file)
@@ -16,7 +16,7 @@ class AliAltroMapping;
 
 class AliTPCRawStreamFast: public AliAltroRawStreamFast {
   public :
-    AliTPCRawStreamFast(AliRawReader* rawReader);
+    AliTPCRawStreamFast(AliRawReader* rawReader, AliAltroMapping **mapping = NULL);
     virtual ~AliTPCRawStreamFast();
 
     virtual void             Reset();