- configure adapted to the new directory structure of the HOMER module in PubSub
authorrichterm <richterm@f7af4fe6-9843-0410-8265-dc069ae4e863>
Wed, 8 Nov 2006 15:50:29 +0000 (15:50 +0000)
committerrichterm <richterm@f7af4fe6-9843-0410-8265-dc069ae4e863>
Wed, 8 Nov 2006 15:50:29 +0000 (15:50 +0000)
- TPCLib
  - AliHLTTPCPad: occupancy calculation added
  - AliHLTTPCClusterFinder bugfix in order to avoid empty cluster data structure and component dead lock
  - AliHLTTPCClusterFinder adapted to use occupancy level for suppression of noisy pads
  - AliHLTTPCClusterFinderComponent: new parameter 'occupancy-limit' which is effectice when pp-run option is set
  - AliHLTTPCDigitReaderRaw 2 more rawreader modes ( 4, 5) are added by Timm.
    In Simulated data the RCU trailer word seems to have 2 32 bit words ( but its not defined like this)
    -> mode 4: 2 32 bit words, sorted
    -> mode 5: 2 32 bit words, unsorted
  - AliHLTTPCSliceTrackerComponent bugfix variable initialisation (by Timm?)
  - AliHLTTPCTransform changed N TimeBins to 1024 according to raw TPC data
    added automatic calculation of timebin width out of N TimeBins
  - OnlineDisplay: intermediate version (Jochen)
    - eventID added
    - range, all, and one TimeBin selectable
    - Front view shows maximum, average, and sum of selected  timebins
    - zerosupression of raw data added to PadRow, Pad, Front, 3D

18 files changed:
HLT/ChangeLog
HLT/TPCLib/AliHLTTPCClusterFinder.cxx
HLT/TPCLib/AliHLTTPCClusterFinder.h
HLT/TPCLib/AliHLTTPCClusterFinderComponent.cxx
HLT/TPCLib/AliHLTTPCDigitReaderRaw.cxx
HLT/TPCLib/AliHLTTPCDigitReaderRaw.h
HLT/TPCLib/AliHLTTPCPad.cxx
HLT/TPCLib/AliHLTTPCPad.h
HLT/TPCLib/AliHLTTPCSliceTrackerComponent.cxx
HLT/TPCLib/AliHLTTPCTransform.cxx
HLT/TPCLib/OnlineDisplay/AliHLTTPCDisplay3D.cxx
HLT/TPCLib/OnlineDisplay/AliHLTTPCDisplayFront.cxx
HLT/TPCLib/OnlineDisplay/AliHLTTPCDisplayMain.cxx
HLT/TPCLib/OnlineDisplay/AliHLTTPCDisplayMain.h
HLT/TPCLib/OnlineDisplay/AliHLTTPCDisplayPad.cxx
HLT/TPCLib/OnlineDisplay/AliHLTTPCDisplayPad.h
HLT/TPCLib/OnlineDisplay/AliHLTTPCDisplayPadRow.cxx
HLT/configure.ac

index 27aef1e..f6b9062 100644 (file)
@@ -1,3 +1,28 @@
+2006-11-08
+       - configure adapted to the new directory structure of the HOMER module in
+         PubSub
+       - TPCLib
+         - AliHLTTPCPad: occupancy calculation added
+         - AliHLTTPCClusterFinder bugfix in order to avoid empty cluster data structure and
+           component dead lock
+         - AliHLTTPCClusterFinder adapted to use occupancy level for suppression of 
+           noisy pads
+         - AliHLTTPCClusterFinderComponent: new parameter 'occupancy-limit' which is effectice
+           when pp-run option is set
+         - AliHLTTPCDigitReaderRaw
+           2 more rawreader modes ( 4, 5) are added by Timm.
+            In Simulated data the RCU trailer word seems to have 2 32 bit words ( but its not
+           defined like this)
+           -> mode 4: 2 32 bit words, sorted
+           -> mode 5: 2 32 bit words, unsorted
+         - AliHLTTPCSliceTrackerComponent bugfix variable initialisation (by Timm?)
+         - AliHLTTPCTransform changed N TimeBins to 1024 according to raw TPC data
+           added automatic calculation of timebin width out of N TimeBins
+         - OnlineDisplay: intermediate version
+           - eventID added
+           - range, all, and one TimeBin selectable
+           - Front view shows maximum, average, and sum of selected timebins
+           - zerosupression of raw data added to PadRow, Pad, Front, 3D
 2006-10-12 added the PHOS library to the package
 2006-10-05 extensions in AliHLTTPCDisplay
        - handling of new include directory structure of the HOMER header files
index 3ad37f0..9e92fd9 100644 (file)
@@ -100,6 +100,7 @@ AliHLTTPCClusterFinder::AliHLTTPCClusterFinder()
   fMatch(1),
   fThreshold(10),
   fSignalThreshold(-1),
+  fOccupancyLimit(1.0),
   fXYErr(0.2),
   fZErr(0.3),
   fDeconvPad(kTRUE),
@@ -119,6 +120,7 @@ AliHLTTPCClusterFinder::AliHLTTPCClusterFinder(const AliHLTTPCClusterFinder& src
   fMatch(src.fMatch),
   fThreshold(src.fThreshold),
   fSignalThreshold(src.fSignalThreshold),
+  fOccupancyLimit(src.fOccupancyLimit),
   fXYErr(src.fXYErr),
   fZErr(src.fZErr),
   fDeconvPad(src.fDeconvPad),
@@ -137,6 +139,7 @@ AliHLTTPCClusterFinder& AliHLTTPCClusterFinder::operator=(const AliHLTTPCCluster
   fMatch=src.fMatch;
   fThreshold=src.fThreshold;
   fSignalThreshold=src.fSignalThreshold;
+  fOccupancyLimit=src.fOccupancyLimit;
   fXYErr=src.fXYErr;
   fZErr=src.fZErr;
   fDeconvPad=src.fDeconvPad;
@@ -204,7 +207,10 @@ void AliHLTTPCClusterFinder::ProcessDigits()
   fDigitReader->InitBlock(fPtr,fSize,fFirstRow,fLastRow,fCurrentPatch,fCurrentSlice);
   readValue = fDigitReader->Next();
 
-  if (!readValue)return;
+  // Matthias 08.11.2006 the following return would cause termination without writing the
+  // ClusterData and thus would block the component. I just wnt to have the commented line
+  // here for information
+  //if (!readValue)return;
 
   pad = fDigitReader->GetPad();
   time = fDigitReader->GetTime();
@@ -315,9 +321,16 @@ void AliHLTTPCClusterFinder::ProcessDigits()
       }
 
       if (pCurrentPad) {
-       charge = pCurrentPad->GetCorrectedData();
+       Float_t occupancy=pCurrentPad->GetOccupancy();
+       //HLTDebug("pad %d occupancy level: %f", pCurrentPad->GetPadNumber(), occupancy);
+       if ( occupancy < fOccupancyLimit ) {
+         charge = pCurrentPad->GetCorrectedData();
+       } else {
+         charge = 0;
+         //HLTDebug("ignoring pad %d with occupancy level %f", pCurrentPad->GetPadNumber(), occupancy);
+       }
       } else {
-      charge = fDigitReader->GetSignal();
+       charge = fDigitReader->GetSignal();
       }
       //HLTDebug("get next charge value: position %d charge %d", time, charge);
 
index b262e3c..c7494de 100644 (file)
@@ -53,6 +53,9 @@ class AliHLTTPCClusterFinder : public AliHLTLogging {
   Int_t fMaxNClusters;   //max. number of clusters
   Float_t fXYErr;        //fixed error in XY
   Float_t fZErr;         //fixed error in Z
+  
+  Float_t fOccupancyLimit; // Occupancy Limit
+
 
 #ifdef do_mc
   void GetTrackID(Int_t pad,Int_t time,Int_t *trackID);
@@ -81,6 +84,7 @@ class AliHLTTPCClusterFinder : public AliHLTLogging {
   void SetZError(Float_t f) {fZErr=f;}
   void SetDeconv(Bool_t f) {fDeconvPad=f; fDeconvTime=f;}
   void SetThreshold(UInt_t i) {fThreshold=i;}
+  void SetOccupancyLimit(Float_t f) {fOccupancyLimit=f;}
   void SetSignalThreshold(Int_t i) {fSignalThreshold=i;}
   void SetMatchWidth(UInt_t i) {fMatch=i;}
   void SetSTDOutput(Bool_t f=kFALSE) {fStdout=f;}  
index 61a0368..fa990d6 100644 (file)
@@ -127,6 +127,7 @@ int AliHLTTPCClusterFinderComponent::DoInit( int argc, const char** argv )
 
     Int_t rawreadermode =  -1;
     Int_t sigthresh = -1;
+    Float_t occulimit = 1.0;
 
     // Data Format version numbers:
     // 0: RCU Data format as delivered during TPC commissioning, pads/padrows are sorted, RCU trailer is one 32 bit word.
@@ -192,6 +193,17 @@ int AliHLTTPCClusterFinderComponent::DoInit( int argc, const char** argv )
        continue;
       }
 
+      // -- pad occupancy limit
+      if ( !strcmp( argv[i], "occupancy-threshold" ) ) {
+       occulimit = strtof( argv[i+1], &cpErr);
+       if ( *cpErr ) {
+         HLTError("Cannot convert occupancy specifier '%s'.", argv[i+1]);
+         return EINVAL;
+       }
+       i+=2;
+       continue;
+      }
+
       Logging(kHLTLogError, "HLT::TPCClusterFinder::DoInit", "Unknown Option", "Unknown option '%s'", argv[i] );
       return EINVAL;
 
@@ -222,8 +234,16 @@ int AliHLTTPCClusterFinderComponent::DoInit( int argc, const char** argv )
       fReader = new AliHLTTPCDigitReaderUnpacked();
       fClusterFinder->SetReader(fReader);
     }
+
+    // if pp-run use occupancy limit else set to 1. ==> use all 
+    if ( !fClusterDeconv )
+      fClusterFinder->SetOccupancyLimit(occulimit);
+    else 
+      fClusterFinder->SetOccupancyLimit(1.0);
       
     // Variables to setup the Clusterfinder
+    // TODO: this sounds strange and has to be verified; is the cluster finder not working when
+    // fClusterDeconv = false ?
     fClusterDeconv = true;
     fXYClusterError = -1;
     fZClusterError = -1;
index 5466254..a53f59c 100644 (file)
@@ -57,7 +57,7 @@ AliHLTTPCDigitReaderRaw::AliHLTTPCDigitReaderRaw( unsigned formatVersion )
   fNTimeBins(0),
   fData(NULL)
 {
-    if ( fDataFormatVersion==0 || fDataFormatVersion==2 )
+    if ( fDataFormatVersion==0 || fDataFormatVersion==2 || fDataFormatVersion==4 )
       {
        
        // get max number of rows
@@ -73,8 +73,8 @@ AliHLTTPCDigitReaderRaw::AliHLTTPCDigitReaderRaw( unsigned formatVersion )
        // get max number of bins
        fNTimeBins = AliHLTTPCTransform::GetNTimeBins();
        
-       HLTDebug("Array Borders ||| MAXPAD=%d ||| MAXROW=%d ||| MAXBIN=%d ||| MAXMUL=%d", 
-                fNMaxPads, fNMaxRows, fNTimeBins, fNTimeBins*fNMaxRows*fNMaxPads);
+       //      HLTDebug("Array Borders ||| MAXPAD=%d ||| MAXROW=%d ||| MAXBIN=%d ||| MAXMUL=%d", 
+       //       fNMaxPads, fNMaxRows, fNTimeBins, fNTimeBins*fNMaxRows*fNMaxPads);
        
        // init Data array
        fData = new Int_t[ fNMaxRows*fNMaxPads*fNTimeBins ];
@@ -128,7 +128,7 @@ AliHLTTPCDigitReaderRaw& AliHLTTPCDigitReaderRaw::operator=(const AliHLTTPCDigit
 }
 
 AliHLTTPCDigitReaderRaw::~AliHLTTPCDigitReaderRaw(){
-  if ( fDataFormatVersion==0 || fDataFormatVersion==2 )
+  if ( fDataFormatVersion==0 || fDataFormatVersion==2 || fDataFormatVersion==4 )
     {
       if ( fData )
        delete [] fData;
@@ -166,7 +166,7 @@ int AliHLTTPCDigitReaderRaw::InitBlock(void* ptr,unsigned long size, Int_t patch
     Int_t firstrow=AliHLTTPCTransform::GetFirstRow(patch);
     Int_t lastrow=AliHLTTPCTransform::GetLastRow(patch);
 
-    if ( fDataFormatVersion==0 || fDataFormatVersion==2 )
+    if ( fDataFormatVersion==0 || fDataFormatVersion==2 || fDataFormatVersion==4 )
       {
        fCurrentRow = 0;
        fCurrentPad = 0;
@@ -238,7 +238,7 @@ int AliHLTTPCDigitReaderRaw::InitBlock(void* ptr,unsigned long size, Int_t patch
 }
 
 bool AliHLTTPCDigitReaderRaw::Next(){
-  if ( fDataFormatVersion==0 || fDataFormatVersion==2 )
+  if ( fDataFormatVersion==0 || fDataFormatVersion==2 || fDataFormatVersion==4 )
     {
       Bool_t readvalue = kTRUE;
       while (1) {
@@ -273,7 +273,7 @@ bool AliHLTTPCDigitReaderRaw::Next(){
 }
 
 int AliHLTTPCDigitReaderRaw::GetRow(){
-  if ( fDataFormatVersion==0 || fDataFormatVersion==2 )
+  if ( fDataFormatVersion==0 || fDataFormatVersion==2 || fDataFormatVersion==4 )
     {
       return (fCurrentRow + fRowOffset);
     }
@@ -281,7 +281,7 @@ int AliHLTTPCDigitReaderRaw::GetRow(){
     return GetRealRow();
 }
 int AliHLTTPCDigitReaderRaw::GetPad(){
-  if ( fDataFormatVersion==0 || fDataFormatVersion==2 )
+  if ( fDataFormatVersion==0 || fDataFormatVersion==2 || fDataFormatVersion==4 )
     {
       return fCurrentPad;
     }
@@ -289,7 +289,7 @@ int AliHLTTPCDigitReaderRaw::GetPad(){
     return GetRealPad();
 }
 int AliHLTTPCDigitReaderRaw::GetSignal(){
-  if ( fDataFormatVersion==0 || fDataFormatVersion==2 )
+  if ( fDataFormatVersion==0 || fDataFormatVersion==2 || fDataFormatVersion==4 )
     {
       return fData[ fCurrentRow*fNMaxPads*fNTimeBins+ fCurrentPad*fNTimeBins + fCurrentBin ];
     }
@@ -297,7 +297,7 @@ int AliHLTTPCDigitReaderRaw::GetSignal(){
     return GetRealSignal();
 }
 int AliHLTTPCDigitReaderRaw::GetTime(){
-  if ( fDataFormatVersion==0 || fDataFormatVersion==2 )
+  if ( fDataFormatVersion==0 || fDataFormatVersion==2 || fDataFormatVersion==4 )
     {
       return fCurrentBin;
     }
@@ -339,19 +339,22 @@ int AliHLTTPCDigitReaderRaw::GetRealTime(){
     return fBunchTimebinStart-(fWordInBunch-2);
 }
 
-AliHLTUInt32_t AliHLTTPCDigitReaderRaw::GetRCUTrailer(){
+AliHLTUInt32_t AliHLTTPCDigitReaderRaw::GetRCUTrailer( unsigned offset ){
   if (fBufferSize<=0) return 0;
   unsigned rcuDataBlockLen = GetRCUDataBlockLength(); 
-  return *((AliHLTUInt32_t*)(fBuffer+fBufferSize-rcuDataBlockLen));
+  if ( offset >= rcuDataBlockLen ) return 0;
+  return ((AliHLTUInt32_t*)(fBuffer+fBufferSize-rcuDataBlockLen))[offset];
 }
 
 bool AliHLTTPCDigitReaderRaw::NextAltroBlock()
     {
     if (fBufferSize<=0) return 0;
+    bool first = false;
     if ( !fAltroBlockLengthBytes )
        {
        // First block in back linked list (last block in memory)
        fAltroBlockPositionBytes = fBufferSize-GetRCUDataBlockLength();
+       first = true;
        }
     else
        {
@@ -365,7 +368,19 @@ bool AliHLTTPCDigitReaderRaw::NextAltroBlock()
        }
 
       AliHLTUInt64_t altroTrailerWord = GetAltroBlock40BitWord( 0 );
+      // Undefined hack from experience to match fill words appearing in simulated data
+      // Seem to be between 0 and 3 fill words, most likely to bring the number of 40bit words
+      // to a multiple of four / to bring the total number of bytes to a common multiple of 4 and 5.
+      // (RCU sends 40 bit (5 byte) words, DDL uses 32 bit (4 bytes) words.
+      unsigned short tmpCnt=0;
+      //HLTDebug( "Altro trailer word 0: 0x%016LX\n", altroTrailerWord );
+      while ( first && altroTrailerWord==0x000000AAAAAAAAAAULL && tmpCnt++<4 ) // Allow up to 4 fill values
+       {
+         altroTrailerWord = GetAltroBlock40BitWord( tmpCnt );
+         //HLTDebug( "Altro trailer word %hu: 0x%016LX\n", tmpCnt, altroTrailerWord );
+       }
 
+      fAltroBlockPositionBytes -= 5*tmpCnt;
       if ( fVerify && ((altroTrailerWord & 0xFFFC000000ULL)!=0xAAA8000000ULL) )
        {
          HLTFatal("Data inconsistency in Altro Block at byte position %#x (%d): Expected 0x2AAA in high 14 bits of altro trailer word; Found %#llx (%#llx)",
@@ -504,6 +519,10 @@ unsigned AliHLTTPCDigitReaderRaw::GetRCUDataBlockLength() const
        case 3:
            return 12;
            break;
+       case 4:
+       case 5:
+           return 8;
+           break;
        default:
            return fBufferSize;
        }
index c142345..df82b2b 100644 (file)
@@ -30,6 +30,8 @@
  *  - 1: As 0, but pads/padrows are delivered "as is", without sorting
  *  - 2: As 0, but RCU trailer is 3 32 bit words.
  *  - 3: As 1, but RCU trailer is 3 32 bit words.
+ *  - 4: As 0, but RCU trailer is 2 32 bit words.
+ *  - 5: As 1, but RCU trailer is 2 32 bit words.
  * @ingroup alihlt_tpc
  */
 class AliHLTTPCDigitReaderRaw : public AliHLTTPCDigitReader  {
@@ -104,7 +106,7 @@ public:
     int GetRealTime();
 
   // Low level methods for accessing the data
-    AliHLTUInt32_t GetRCUTrailer();
+    AliHLTUInt32_t GetRCUTrailer( unsigned offset=0 );
     bool NextAltroBlock();
     AliHLTUInt32_t GetAltroBlockHWaddr();
     unsigned GetAltroBlock10BitWordCnt();
index c6f6637..43fb9f7 100644 (file)
@@ -323,8 +323,27 @@ AliHLTTPCSignal_t AliHLTTPCPad::GetRawData(Int_t bin) const
 AliHLTTPCSignal_t AliHLTTPCPad::GetCorrectedData(Int_t bin) const
 {
   AliHLTTPCSignal_t data=GetRawData(bin)-GetBaseLine(bin);
-  if (fThreshold>0) data-=fThreshold;
+  AliHLTTPCSignal_t prev=0;
+  if (bin>1) prev=GetRawData(bin-1)-GetBaseLine(bin-1);
+  AliHLTTPCSignal_t succ=0;
+  if (bin+1<GetSize()) succ=GetRawData(bin+1)-GetBaseLine(bin+1);
+  if (fThreshold>0) {
+    data-=fThreshold;
+    prev-=fThreshold;
+    succ-=fThreshold;
+  }
+  // case 1:
+  // the signal is below the base-line and threshold
   if (data<0) data=0;
+
+  //case 2:
+  // the neighboring bins are both below base-line/threshold
+  // a real signal is always more than one bin wide because of the shaper 
+  if (prev<=0 && succ<=0) data=0;
+  // case 3:
+  // the bin is inside the range of ignored bins
   if (bin<fFirstBLBin) data=0;
   //HLTDebug("fReadPos=%d data=%d threshold=%d raw data=%d base line=%d", fReadPos, data, fThreshold, GetRawData(bin), GetBaseLine(bin));
   return data;
@@ -338,8 +357,10 @@ AliHLTTPCSignal_t AliHLTTPCPad::GetBaseLine(Int_t bin) const
     // the average to much
     const AliHLTTPCSignal_t kMaxDifference=15;
     val=fAverage;
+#ifdef KEEP_NOISE
     if ((fAverage-fBLMin)<=kMaxDifference) val=fBLMin;
     else val>kMaxDifference?val-=kMaxDifference:0;
+#endif
   }
   if (val<0) {
     // here we should never get
@@ -354,3 +375,21 @@ AliHLTTPCSignal_t AliHLTTPCPad::GetAverage() const
   return fAverage>0?fAverage:0;
 }
 
+Float_t AliHLTTPCPad::GetOccupancy() const
+{
+  Float_t occupancy=0;
+  if (fpRawData && fNofBins>0) {
+    for (Int_t i=fFirstBLBin; i<fNofBins; i++) {
+      if (GetCorrectedData(i)>0) occupancy+=1;
+    }
+    if (fNofBins-fFirstBLBin>0)
+      occupancy/=fNofBins-fFirstBLBin;
+  }
+  return occupancy;
+}
+
+Float_t AliHLTTPCPad::GetAveragedOccupancy() const
+{
+  // history is not yet implemented
+  return GetOccupancy();
+}
index 2db9520..00dec1f 100644 (file)
@@ -203,6 +203,22 @@ class AliHLTTPCPad : public AliHLTLogging {
   AliHLTTPCSignal_t GetAverage() const;
 
   /**
+   * Get the occupancy for the pad in fractions of 1
+   * The occupancy is calculated from the number of time bins with non zero data
+   * after zero suppression.
+   * @return occupancy in percent
+   */
+  Float_t GetOccupancy() const;
+
+  /**
+   * Get the occupancy average for the pad in fractions of 1
+   * The occupancy is calculated from the number of time bins with non zero data
+   * after zero suppression and averaged over all events.
+   * @return occupancy in percent
+   */
+  Float_t GetAveragedOccupancy() const;
+
+  /**
    * Get the size (number of time bins) of the pad
    * @return number of bins 
    */
index 73733c9..5cb797c 100644 (file)
@@ -415,6 +415,11 @@ int AliHLTTPCSliceTrackerComponent::DoEvent( const AliHLTComponent_EventData& ev
                                              AliHLTUInt32_t& size, vector<AliHLTComponent_BlockData>& outputBlocks )
     {
     Logging( kHLTLogDebug, "HLT::TPCSliceTracker::DoEvent", "DoEvent", "DoEvent()" );
+    if ( evtData.fBlockCnt<=0 )
+      {
+       Logging( kHLTLogWarning, "HLT::TPCSliceTracker::DoEvent", "DoEvent", "no blocks in event" );
+       return 0;
+      }
     const AliHLTComponent_BlockData* iter = NULL;
     unsigned long ndx;
     AliHLTTPCClusterData* inPtrSP;
@@ -425,14 +430,14 @@ int AliHLTTPCSliceTrackerComponent::DoEvent( const AliHLTComponent_EventData& ev
     AliHLTUInt32_t vSize = 0;
     UInt_t offset=0, mysize, tSize = 0;
     outBPtr = outputPtr;
-    Int_t slice, patch, row[2];
+    Int_t slice=-1, patch=-1, row[2];
     Int_t minPatch=INT_MAX, maxPatch = 0;
     offset = 0;
     std::vector<Int_t> slices;
     std::vector<Int_t>::iterator slIter, slEnd;
     std::vector<unsigned> sliceCnts;
     std::vector<unsigned>::iterator slCntIter;
-    Int_t vertexSlice=0;
+    Int_t vertexSlice=-1;
 
     // Find min/max rows used in total and find and read out vertex if it is present
     // also determine correct slice number, if multiple slice numbers are present in event
@@ -516,8 +521,14 @@ int AliHLTTPCSliceTrackerComponent::DoEvent( const AliHLTComponent_EventData& ev
        Logging( kHLTLogError, "HLT::TPCSliceTracker::DoEvent", "Multiple slices found in event",
                 "Using slice %lu.", slice );
        }
-    else
+    else if ( slices.size()>0 )
+      {
        slice = *(slices.begin());
+      }
+    else
+      {
+       slice = -1;
+      }
     
     if ( vertexSlice != slice )
        {
index 8a810a5..c0d015d 100644 (file)
@@ -100,7 +100,7 @@ Double_t AliHLTTPCTransform::fgBField = 0.2;
 Double_t AliHLTTPCTransform::fgSolenoidBField = 2;
 Double_t AliHLTTPCTransform::fgBFieldFactor = 1;
 Int_t AliHLTTPCTransform::fgVersion = kVdefault;
-Int_t AliHLTTPCTransform::fgNTimeBins = 1024; //446
+Int_t AliHLTTPCTransform::fgNTimeBins = 1024; //  = 1024; //446
 Int_t AliHLTTPCTransform::fgNRowLow = 63;
 Int_t AliHLTTPCTransform::fgNRowUp = 96;
 Int_t AliHLTTPCTransform::fgNRowUp1 = 64;
@@ -110,9 +110,9 @@ Int_t AliHLTTPCTransform::fgNSectorUp = 36;
 Int_t AliHLTTPCTransform::fgNSector = 72;
 Double_t AliHLTTPCTransform::fgPadPitchWidthLow = 0.4;
 Double_t AliHLTTPCTransform::fgPadPitchWidthUp = 0.6;
-Double_t AliHLTTPCTransform::fgZWidth = 0.5660;
 Double_t AliHLTTPCTransform::fgZSigma = 0.2288;
 Double_t AliHLTTPCTransform::fgZLength = 250.0000;
+Double_t AliHLTTPCTransform::fgZWidth = AliHLTTPCTransform::fgZLength / (Double_t)AliHLTTPCTransform::fgNTimeBins ;//0.5660; // 0.2435; // 0.5660 // Width of time bins
 Double_t AliHLTTPCTransform::fgZOffset = 0.6864;
 Double_t AliHLTTPCTransform::fgDiffT = 0.0220;
 Double_t AliHLTTPCTransform::fgDiffL = 0.0220;
index d386502..ed7c0f8 100644 (file)
@@ -14,6 +14,7 @@
 #define TRACKHELIX 0       // use THelix for tracks
 #define TRACKPOLYMARKER 0  // use TPolymarker3D for tracks
 #define FIRSTLASTPOINT 0   // show first / last point of tracks
+#define DEBUG 1
 
 #define DRAWSTEP 0.2
 
 #define TRACKPOLYMARKERCOLOR 5
 #define TRACKHELIXCOLOR 6
 
+#if defined(HAVE_HOMERREADER) 
+#include "HOMERReader.h"
+#endif // defined(HAVE_HOMERREADER) 
+
 #include "AliHLTTPCDisplay3D.h"
 #include "AliHLTTPCDisplayPadRow.h"
 
@@ -60,6 +65,7 @@
 
 
 #include "AliHLTTPCDigitReader.h"
+#include "AliHLTTPCDigitReaderRaw.h"
 #include "AliHLT_C_Component_WrapperInterface.h"
 
 #include "AliHLTTPCDisplayMain.h"
@@ -474,8 +480,134 @@ void AliHLTTPCDisplay3D::Draw(){
     //--------------------------------------------------------------------------------------------
     // DRAW 3D PadRow
     //--------------------------------------------------------------------------------------------
-    if (fDisplay->Get3DSwitchPadRow() && fDisplay->GetDisplaySlice(fDisplay->GetSlicePadRow())){
-       fDisplay->GetPadRowPointer()->Draw3D();
+    if (fDisplay->ExistsRawData() &&  fDisplay->Get3DSwitchPadRow() && fDisplay->GetDisplaySlice(fDisplay->GetSlicePadRow())){
+
+      // -- only one padrow
+      if ( fDisplay->Get3DSwitchRaw() == 0 ) {
+
+       fDisplay->GetPadRowPointer()->Draw3D();
+      }
+      // show all padrows 
+      else {
+
+#if defined(HAVE_HOMERREADER) 
+       HOMERReader* reader = (HOMERReader*)fDisplay->fReader;
+
+       char* rawID = "KPWR_LDD";
+       ULong_t blk;
+       blk = reader->FindBlockNdx( rawID, " CPT",0xFFFFFFFF );
+
+       Int_t NRawPoints = 0;
+       TPolyMarker3D* pm = new  TPolyMarker3D( );
+       pm->SetBit(kCanDelete);
+       pm->SetMarkerColor(51); 
+    
+       while ( blk != ~(ULong_t)0 ) {
+         
+#if DEBUG
+         printf( "Found raw data block %lu\n", blk );
+#endif
+         // Check for corrupt data
+         AliHLTUInt64_t corruptFlag = reader->GetBlockStatusFlags( blk );
+         if (corruptFlag & 0x00000001) {
+           LOG(AliHLTTPCLog::kError,"AliHLTTPCDisplayMain::ReadData","Block status flags") << "Data block is corrupt"<<ENDLOG; 
+           continue;
+         }
+
+         unsigned long rawDataBlock = (unsigned long) reader->GetBlockData( blk );
+         unsigned long rawDataLen = reader->GetBlockDataLength( blk );
+
+         ULong_t spec = reader->GetBlockDataSpec( blk );
+         Int_t patch = AliHLTTPCDefinitions::GetMinPatchNr( spec );
+         Int_t slice = AliHLTTPCDefinitions::GetMinSliceNr( spec );
+#if DEBUG
+         printf( "Raw data found for slice %u - patch %u\n", slice, patch );
+#endif 
+
+         // slice should(not) be displayed
+         if (!fDisplay->GetDisplaySlice(slice)) continue;
+         
+
+#if defined(HAVE_TPC_MAPPING)
+         AliHLTTPCDigitReaderRaw digitReader(0);
+
+         bool readValue = true;
+         Int_t rowOffset = 0;
+    
+         // Initialize RAW DATA
+         Int_t firstRow = AliHLTTPCTransform::GetFirstRow(patch);
+         Int_t lastRow = AliHLTTPCTransform::GetLastRow(patch);
+         
+         // Outer sector, patches 2, 3, 4, 5 -  start counting in patch 2 with row 0
+         if ( patch >= 2 ) rowOffset = AliHLTTPCTransform::GetFirstRow( 2 );
+
+         // Initialize block for reading packed data
+         void* tmpDataBlock = (void*) rawDataBlock;
+         digitReader.InitBlock(tmpDataBlock,rawDataLen,firstRow,lastRow,patch,slice);
+
+         readValue = digitReader.Next();
+
+         if (!readValue){      
+           LOG(AliHLTTPCLog::kError,"AliHLTTPCDisplayPadRow::Fill","Read first value") << "No value in data block" << ENDLOG;
+           continue;
+         }
+
+
+         //      blk = reader->FindBlockNdx( rawID, " CPT", 0xFFFFFFFF, blk+1 );
+         //      continue;
+
+         // Fill 3D Raw Data
+         while ( readValue ){ 
+           
+           Int_t row = digitReader.GetRow() + rowOffset;
+
+           UChar_t pad = digitReader.GetPad();
+           UShort_t time = digitReader.GetTime();
+           UInt_t charge = digitReader.GetSignal();
+           if ( charge < 50 ) {
+             // read next value
+             readValue = digitReader.Next();
+      
+             if(!readValue) break; //No more value
+             continue;
+           }
+           Float_t xyz[3];
+
+           // Transform raw coordinates to local coordinates
+           AliHLTTPCTransform::RawHLT2Global(xyz, slice, row, pad, time);
+
+           NRawPoints++;
+           pm->SetNextPoint((Double_t)xyz[0],(Double_t)xyz[1],(Double_t)xyz[2]);
+
+           //  printf("%u points\n",NRawPoints);
+
+           // read next value
+           readValue = digitReader.Next();
+      
+           if(!readValue) break; //No more value
+         } // end  while ( readValue ){ 
+
+
+#else //! defined(HAVE_TPC_MAPPING)
+         HLTFatal("DigitReaderRaw not available - check your build");
+#endif //defined(HAVE_TPC_MAPPING)
+         
+         blk = reader->FindBlockNdx( rawID, " CPT", 0xFFFFFFFF, blk+1 );
+
+       } // end while ( blk != ~(ULong_t)0 ) {
+       pm->Draw(); 
+#else
+    HLTFatal("HOMER reader not available");
+#endif // defined(HAVE_HOMERREADER) 
+
+
+       //////////////////////////////
+
+
+
+
+      } // end show all padrows
+
     }
 
     //--------------------------------------------------------------------------------------------
index 7b493c4..85b0eea 100644 (file)
 #include "AliHLTTPCClusterDataFormat.h"
 #include "AliHLTTPCLogging.h"
 #include "AliHLTTPCTransform.h"
-#include "AliHLTTPCDigitReaderPacked.h"
-#include "AliHLTTPCDigitReaderRaw.h"
 
 #include "AliHLTTPCDisplayMain.h"
 #include "AliHLTTPCDisplayFront.h"
-
+#include "AliHLTTPCDisplayPad.h"
 #if __GNUC__ >= 3
 using namespace std;
 #endif
 
+#define TESTCODE 0
+
 ClassImp(AliHLTTPCDisplayFront)
 
 //____________________________________________________________________________________________________
@@ -49,15 +49,31 @@ AliHLTTPCDisplayFront::AliHLTTPCDisplayFront(AliHLTTPCDisplayMain* display) {
     // constructor
     fDisplay = display;
 
-    fNTimes = AliHLTTPCTransform::GetNTimeBins();
-
+    fNTimes = display->GetNTimeBins();
+    
     fBinY[0] = 0;
     fBinY[1] = AliHLTTPCTransform::GetNRows() - 1;
+#if TESTCODE    
+    fBinX[0] = (-4) * AliHLTTPCTransform::GetNPads(fBinY[1]);      
+    fBinX[1] = (4) * AliHLTTPCTransform::GetNPads(fBinY[1]);
+    Int_t Bins =  (8 * AliHLTTPCTransform::GetNPads(fBinY[1]) ) + 1;
+#else
     fBinX[0] = 0;      
     fBinX[1] = AliHLTTPCTransform::GetNPads(fBinY[1]);
+#endif    
     fTmpEvent = 0;    
+    
+    Int_t fBinningFaktor = 4 ;
+    
 
+
+
+#if TESTCODE
+    fHistfront = new TH2F("fHistfront","FrontView of selected slice;Pad #;Padrow #",Bins,fBinX[0],fBinX[1],fBinY[1]+1,fBinY[0],fBinY[1]);
+#else
     fHistfront = new TH2F("fHistfront","FrontView of selected slice;Pad #;Padrow #",fBinX[1]+1,fBinX[0],fBinX[1],fBinY[1]+1,fBinY[0],fBinY[1]);
+#endif
 
     fHistfront->SetOption("COLZ");  
     fHistfront->SetTitleSize(0.03);
@@ -88,54 +104,152 @@ void AliHLTTPCDisplayFront::Save(){
 
 //____________________________________________________________________________________________________
 void AliHLTTPCDisplayFront::Fill(Int_t patch, ULong_t dataBlock, ULong_t dataLen){
-    // Fill Pad Histogram
+  // Fill Pad Histogram
 
-#if defined(HAVE_TPC_MAPPING)
-    AliHLTTPCDigitReaderRaw digitReader(0);
+  Int_t timeSwitch = fDisplay->GetFrontDataSwitch();
 
-    bool readValue = true;
-    Int_t rowOffset = 0;
-    
-    Int_t timebin = fDisplay->GetTimebin();
-    Bool_t allTimebins = fDisplay->GetAllTimebins();
-    Int_t slice = fDisplay->GetSlicePadRow();
-
-    // Initialize RAW DATA
-    Int_t firstRow = AliHLTTPCTransform::GetFirstRow(patch);
-    Int_t lastRow = AliHLTTPCTransform::GetLastRow(patch);
+  // --- TEST CODE beginn
+  Int_t fBinning = 8; // == 1/0.125
+  Int_t fBinningFaktor = 4; // binning / 2 because of width half
 
-    // Outer sector, patches 2, 3, 4, 5 -  start counting in patch 2 with row 0
-    if ( patch >= 2 ) rowOffset = AliHLTTPCTransform::GetFirstRow( 2 );
+#if TESTCODE
+    // use sum
+    if (timeSwitch == 0) {
+      for (Int_t row=0; row < AliHLTTPCTransform::GetNRows(); row++){
 
-    // Initialize block for reading packed data
-    void* tmpdataBlock = (void*) dataBlock;
-    digitReader.InitBlock(tmpdataBlock,dataLen,firstRow,lastRow,patch,slice);
+       Int_t width_half = AliHLTTPCTransform::GetNPads(row) * AliHLTTPCTransform::GetPadLength(row) * fBinningFaktor;
+       Int_t pad_corrected_loop = (Int_t) ( AliHLTTPCTransform::GetPadLength(row) *fBinning );
 
-    readValue = digitReader.Next();
+       for (Int_t pad=0; pad < AliHLTTPCTransform::GetNPads(row); pad++){
 
-    if (!readValue){   
-       LOG(AliHLTTPCLog::kError,"AliHLTTPCDisplayFrontRow::Fill","Read first value") << "No value in data block" << ENDLOG;
-       return;
-    }
+         Int_t pad_corrected = ( pad * AliHLTTPCTransform::GetPadLength(row) * fBinning ) - width_half;
 
-    // -- Fill Raw Data
-    while ( readValue ){ 
+         UInt_t timeSum = 0;
+         for (Int_t timeBin=fDisplay->GetTimeBinMin(); timeBin <= fDisplay->GetTimeBinMax(); timeBin++){
+           timeSum += fDisplay->fRawData[row][pad][timeBin];
+         } // end time
+         for (Int_t ii=0;ii < pad_corrected_loop; ii++){
+           pad_corrected++;
+           fHistfront->Fill(pad_corrected,row,(Int_t) timeSum);
+         }
+       } // end pad
+      }  // end row
+    } // end use sum
 
-       UShort_t time = digitReader.GetTime();
+    return;
+    // --- TEST CODE end
+#endif
 
-       // check if all timebins or just one
-       if (allTimebins || time == timebin ) 
-           fHistfront->Fill(digitReader.GetPad(),(digitReader.GetRow() + rowOffset),digitReader.GetSignal());
+  // !!
+  // !!  DO unrolling because of cache effects (avoid cache trashing) !!
+  // !!
+  
+  if ( fDisplay->GetZeroSuppression() ){
+    // use sum
+    if (timeSwitch == 0) {
+      for (Int_t row=0; row < AliHLTTPCTransform::GetNRows(); row++){
+       for (Int_t pad=0; pad < AliHLTTPCTransform::GetNPads(row); pad++){
+         UInt_t timeSum = 0;
+         for (Int_t timeBin=fDisplay->GetTimeBinMin(); timeBin <= fDisplay->GetTimeBinMax(); timeBin++){
+           timeSum += fDisplay->fRawDataZeroSuppressed[row][pad][timeBin];
+         } // end time
+         
+         fHistfront->Fill(pad,row,(Int_t) timeSum);
+       } // end pad
+      }  // end row
+    } // end use sum
+    
+    // use average
+    else if (timeSwitch == 1){
+      for (Int_t row=0; row < AliHLTTPCTransform::GetNRows(); row++){
+       for (Int_t pad=0; pad < AliHLTTPCTransform::GetNPads(row); pad++){
+         UInt_t timeSum = 0;
+         Int_t NTimeBins = 0;
+         Float_t timeAverage = 0.;
+         for (Int_t timeBin=fDisplay->GetTimeBinMin(); timeBin <= fDisplay->GetTimeBinMax(); timeBin++){
+           timeSum += fDisplay->fRawDataZeroSuppressed[row][pad][timeBin];
+           NTimeBins++;
+         } // end time
+         
+         if (NTimeBins <= 0) 
+           HLTFatal("Division by Zero - NTimeBins == 0");
+         else
+           timeAverage = ((Float_t) timeSum) / ((Float_t) NTimeBins);
+         
+         fHistfront->Fill(pad,row, timeAverage);
+       } // end pad
+      }  // end row
+    }// end use average
+    
+    // use maximum
+    else if (timeSwitch == 2){
+      for (Int_t row=0; row < AliHLTTPCTransform::GetNRows(); row++){
+       for (Int_t pad=0; pad < AliHLTTPCTransform::GetNPads(row); pad++){
+         UInt_t timeMax = 0;
+         for (Int_t timeBin=fDisplay->GetTimeBinMin(); timeBin <= fDisplay->GetTimeBinMax(); timeBin++){
+           UInt_t tmp = fDisplay->fRawDataZeroSuppressed[row][pad][timeBin];
+           if (tmp > timeMax) timeMax = tmp;
+         } // end time
+       
+         fHistfront->Fill(pad,row,(Int_t) timeMax);
+       } // end pad
+      }  // end row
+    }// end use maximum
+  }  // end - if ( fDisplay->GetZeroSuppression() ){
+
+  else {
+    // use sum
+    if (timeSwitch == 0) {
+      for (Int_t row=0; row < AliHLTTPCTransform::GetNRows(); row++){
+       for (Int_t pad=0; pad < AliHLTTPCTransform::GetNPads(row); pad++){
+         UInt_t timeSum = 0;
+         for (Int_t timeBin=fDisplay->GetTimeBinMin(); timeBin <= fDisplay->GetTimeBinMax(); timeBin++){
+           timeSum += fDisplay->fRawData[row][pad][timeBin];
+         } // end time
+         
+         fHistfront->Fill(pad,row,(Int_t) timeSum);
+       } // end pad
+      }  // end row
+    } // end use sum
+    
+    // use average
+    else if (timeSwitch == 1){
+      for (Int_t row=0; row < AliHLTTPCTransform::GetNRows(); row++){
+       for (Int_t pad=0; pad < AliHLTTPCTransform::GetNPads(row); pad++){
+         UInt_t timeSum = 0;
+         Int_t NTimeBins = 0;
+         Float_t timeAverage = 0.;
+         for (Int_t timeBin=fDisplay->GetTimeBinMin(); timeBin <= fDisplay->GetTimeBinMax(); timeBin++){
+           timeSum += fDisplay->fRawData[row][pad][timeBin];
+           NTimeBins++;
+         } // end time
+         
+         if (NTimeBins <= 0) 
+           HLTFatal("Division by Zero - NTimeBins == 0");
+         else
+           timeAverage = ((Float_t) timeSum) / ((Float_t) NTimeBins);
+         
+         fHistfront->Fill(pad,row, timeAverage);
+       } // end pad
+      }  // end row
+    }// end use average
+    
+    // use maximum
+    else if (timeSwitch == 2){
+      for (Int_t row=0; row < AliHLTTPCTransform::GetNRows(); row++){
+       for (Int_t pad=0; pad < AliHLTTPCTransform::GetNPads(row); pad++){
+         UInt_t timeMax = 0;
+         for (Int_t timeBin=fDisplay->GetTimeBinMin(); timeBin <= fDisplay->GetTimeBinMax(); timeBin++){
+           UInt_t tmp = fDisplay->fRawData[row][pad][timeBin];
+           if (tmp > timeMax) timeMax = tmp;
+         } // end time
        
-       // read next value
-       readValue = digitReader.Next();
-      
-       //Check where to stop:
-       if(!readValue) break; //No more value
-    } 
-#else //! defined(HAVE_TPC_MAPPING)
-      HLTFatal("DigitReaderRaw not available - check your build");
-#endif //defined(HAVE_TPC_MAPPING)
+         fHistfront->Fill(pad,row,(Int_t) timeMax);
+       } // end pad
+      }  // end row
+    }// end use maximum
+  } // end - else of  if ( fDisplay->GetZeroSuppression() ){
+
 }
 
 //____________________________________________________________________________________________________
@@ -143,6 +257,11 @@ void AliHLTTPCDisplayFront::Draw(){
     fDisplay->GetCanvasFront()->cd();
     fDisplay->GetCanvasFront()->Clear();
 
+    if (fDisplay->GetSplitFront()){
+      fDisplay->GetCanvasFront()->Divide(1,2);
+      fDisplay->GetCanvasFront()->cd(1);
+    }
+
     Char_t title[256];
     sprintf(title,"FrontView of selected slice%d",fDisplay->GetSlicePadRow());
 
@@ -161,12 +280,16 @@ void AliHLTTPCDisplayFront::Draw(){
     fHistfront->SetStats(kFALSE);
     fHistfront->Draw("COLZ");
 
+    if (fDisplay->GetSplitFront()){
+      fDisplay->GetCanvasFront()->cd(2);
+      fDisplay->GetPadPointer()->fHistpad2->Draw();
+    }
+
     fDisplay->GetCanvasFront()->Modified();
     fDisplay->GetCanvasFront()->Update();
 
     // Select Pad
-    // fCanvas->Connect("ProcessedEvent(Int_t,Int_t,Int_t,TObject*)","AliHLTTPCDisplayFront",(void*) fDisplay,"ExecPadEvent(Int_t,Int_t,Int_t,TObject*)");
-
+    fDisplay->GetCanvasFront()->Connect("ProcessedEvent(Int_t,Int_t,Int_t,TObject*)","AliHLTTPCDisplayMain",(void*) fDisplay,"ExecPadEvent(Int_t,Int_t,Int_t,TObject*)");
     // Keep Zoom
     fDisplay->GetCanvasFront()->Connect("ProcessedEvent(Int_t,Int_t,Int_t,TObject*)","AliHLTTPCDisplayFront",(void*) this,"ExecEvent(Int_t,Int_t,Int_t,TObject*)");
 }
index 25a0911..06e96e6 100644 (file)
@@ -33,6 +33,8 @@
 #include "AliHLTTPCClusterDataFormat.h"
 #include "AliHLTTPCTrackletDataFormat.h"
 #include "AliHLTTPCDigitReader.h"
+#include "AliHLTTPCDigitReaderRaw.h"
+#include "AliHLTTPCPad.h"
 #include "AliHLT_C_Component_WrapperInterface.h"
 #include "AliHLTTPCLogging.h"
 
@@ -57,102 +59,106 @@ ClassImp(AliHLTTPCDisplayMain)
 
 //____________________________________________________________________________________________________
 AliHLTTPCDisplayMain::AliHLTTPCDisplayMain(void* pt2GUI, void (*pt2Function)(void*, Int_t)) {
-    //constructor
+  //constructor
 
-    // Set B-Field
-    AliHLTTPCTransform::SetBField( 0.8 );
+  // set N of TimeBins
+  fgNTimeBins = 1024;   //  446 or 1024
 
-    //callback handler
-    fPt2Gui = pt2GUI;
-    fPadCallback = pt2Function;
+  //callback handler
+  fPt2Gui = pt2GUI;
+  fPadCallback = pt2Function;
        
-    fReader = NULL;
-
-    fDisplayCharge = NULL; 
-    fDisplayPadRow = NULL;
-    fDisplayPad = NULL;
-    fDisplay3D = NULL;
-    fDisplayResiduals = NULL;
-    fDisplayFront = NULL;
-
-    fCanvasCharge = NULL;
-    fCanvasPadRow = NULL;
-    fCanvasPad = NULL;
-    fCanvas3D = NULL;
-    fCanvasResiduals = NULL;
-    fCanvasFront = NULL;
-    fCanvasHits_S = NULL;
-    fCanvasQ_Track = NULL;
-    fCanvasQ_S = NULL;
-
-    fConnect = kFALSE;
-
-    fExistsRawData = kFALSE;
-    fExistsClusterData = kFALSE;
-    fExistsTrackData = kFALSE;
-
-    AliHLTTPCTransform::SetBField(0.4);
-
-    memset(fClusters,0,36*6*sizeof(AliHLTTPCSpacePointData*));
-    memset(fNcl, 0, 36*6*sizeof(UInt_t)); 
-
-    fTracks = NULL;
-
-    fTheta = 90.;
-    fPhi = 0.;
-
-    fSwitch3DCluster = kFALSE;
-    fSwitch3DTracks = kFALSE;
-    fSwitch3DPadRow = kFALSE;
-    fSwitch3DGeometry = kTRUE;
-
-
-    // fMinHits = 0;
-    // fPtThreshold = 0.;
-
-    fCutHits = 0;
-    fCutPt = 0.;
-    fCutPsi = 0.;
-    fCutLambda = 0.;
-    fCut_S = 0.;
-    fCutPadrow = 159;
-
-    fNPads = AliHLTTPCTransform::GetNPads(0);
-    fPad = -1;
-    fPadRow = 0;
-    fTimebin = 0;
-
-    fAllTimebins = kTRUE;
-    fSplitPadRow = kFALSE;
+  fReader = NULL;
+  
+  fConnect = kFALSE;
+  fEventID = 0;
+
+
+  fDisplayCharge = NULL; 
+  fDisplayPadRow = NULL;
+  fDisplayPad = NULL;
+  fDisplay3D = NULL;
+  fDisplayResiduals = NULL;
+  fDisplayFront = NULL;
+
+  fCanvasCharge = NULL;
+  fCanvasPadRow = NULL;
+  fCanvasPad = NULL;
+  fCanvas3D = NULL;
+  fCanvasResiduals = NULL;
+  fCanvasFront = NULL;
+  fCanvasHits_S = NULL;
+  fCanvasQ_Track = NULL;
+  fCanvasQ_S = NULL;
+  fCanvasPadRow_Pad = NULL;
+
+
+  fExistsRawData = kFALSE;
+  fExistsClusterData = kFALSE;
+  fExistsTrackData = kFALSE;
+
+  memset(fClusters,0,36*6*sizeof(AliHLTTPCSpacePointData*));
+  memset(fNcl, 0, 36*6*sizeof(UInt_t)); 
+
+  fTracks = NULL;
+
+  fZeroSuppression = kTRUE;
+  fNPads = AliHLTTPCTransform::GetNPads(0);
+  fPad = -1;
+  fPadRow = 0;
+  fSlicePadRow = 0; 
+  fSplitPadRow = kFALSE;
+  
+  fFrontDataSwitch = 2;
+  fTimeBinMin = 0;
+  fTimeBinMax = GetNTimeBins() -1;
+  fSplitFront = kFALSE;
     
-    fSlicePadRow = 0; 
-    fSelectTrack = -1;
-    fSelectTrackSlice = 0;
-    fSelectTrackSwitch = kFALSE;
-    fSelectCluster = 0;
-
-    fMinSlice = 0;
-    fMaxSlice = 35;
-    fSlicePair = kFALSE;
-
-    SetSliceArray();
-
-    fBackColor = 1;
-    fLineColor = 0;
-    fKeepView = kTRUE;
-
-    fTrackParam.kappa = 0.;
-    fTrackParam.nHits = 0;
-    fTrackParam.charge = 0;
-    fTrackParam.radius = 0.;
-    fTrackParam.slice = 0;
-    fTrackParam.phi0 = 0.;
-    fTrackParam.psi = 0.;
-    fTrackParam.lambda = 0.;
-    fTrackParam.pt = 0.;
-    fTrackParam.id = 0;
-    fTrackParam.bfield = 0.;
-    fTrackParam.s = 0.;
+  fSelectTrack = -1;
+  fSelectTrackSlice = 0;
+  fSelectTrackSwitch = kFALSE;
+  
+  fSelectCluster = 0;
+
+  fMinSlice = 0;
+  fMaxSlice = 35;
+  fSlicePair = kFALSE;
+
+  SetSliceArray();
+  
+  fTheta = 90.;
+  fPhi = 0.;
+
+  fBackColor = 1;
+  fLineColor = 0;
+  fKeepView = kTRUE;
+
+  fSwitch3DCluster = kFALSE;
+  fSwitch3DTracks = kFALSE;
+  fSwitch3DPadRow = kFALSE;
+  fSwitch3DGeometry = kTRUE;
+  fSwitch3DRaw = 0;
+
+  fCutHits = 0;
+  fCutPt = 0.;
+  fCutPsi = 0.;
+  fCutLambda = 0.;
+  fCut_S = 0.;
+  fCutPadrow = 159;
+  
+
+  fTrackParam.kappa = 0.;
+  fTrackParam.nHits = 0;
+  fTrackParam.charge = 0;
+  fTrackParam.radius = 0.;
+  fTrackParam.slice = 0;
+  fTrackParam.phi0 = 0.;
+  fTrackParam.psi = 0.;
+  fTrackParam.lambda = 0.;
+  fTrackParam.pt = 0.;
+  fTrackParam.id = 0;
+  fTrackParam.bfield = 0.;
+  fTrackParam.s = 0.;
 }
 
 //____________________________________________________________________________________________________
@@ -197,241 +203,241 @@ AliHLTTPCDisplayMain::~AliHLTTPCDisplayMain() {
 //____________________________________________________________________________________________________
 Int_t AliHLTTPCDisplayMain::Connect( unsigned int cnt, const char** hostnames, unsigned short* ports, Char_t *gfile){
 
-    Char_t* defaultGeometry=NULL;
-#if defined(DEFAULT_GEOMETRY)
-    defaultGeometry=DEFAULT_GEOMETRY;
-#endif
-    if (gfile!=NULL) {
-      HLTDebug("probing geometry file %s", gfile);
-      ifstream test(gfile);
-      if (test.fail()) {
-       HLTWarning("unable to find geometry file %s, using default file", gfile);
-       gfile=defaultGeometry;
-      }
-      test.close();
-    } else {
-      HLTDebug("using default geometry file %s", gfile, defaultGeometry);
-      gfile=defaultGeometry;
-    }
-    if (gfile==NULL) {
-      HLTError("geometry file missing");
-      return -EINVAL;
-    }
 #if defined(HAVE_HOMERREADER) 
-    // -- input datatypes , reverse
-    Char_t* spptID="SRETSULC";
-    Char_t* trkID = "SGESKART";
-    Char_t* padrowID = "KPWR_LDD";
-     
-    Int_t ret;
-    Int_t tries = 0;
+  // -- input datatypes , reverse
+  Char_t* spptID="SRETSULC";       // CLUSTERS
+  Char_t* trkID = "SGESKART";      // TRAKSEGS
+  Char_t* padrowID = "KPWR_LDD";   // DDL_RWPK
+  
+  Int_t ret;
+  
+  while(1) {
+
+    // -- CONNECT to TCPDumpSubscriber via HOMER
+    // ---------------------------------------------
+    HOMERReader* reader = new HOMERReader( cnt, (const char**) hostnames, ports );
+    ret=reader->GetConnectionStatus();
     
-    while(1) {
-       HOMERReader* reader = new HOMERReader( cnt, (const char**) hostnames, ports );
-
-       ret=reader->GetConnectionStatus();
-
-       if ( ret ) {    
-           Int_t ndx = reader->GetErrorConnectionNdx();
-           if ( ndx < (Int_t) cnt) printf( "Error establishing connection to TCP source %s:%hu: %s (%d)\n", hostnames[ndx], ports[ndx], strerror(ret), ret );
-           else printf( "Error establishing connection to unknown source with index %d: %s (%d)\n",ndx, strerror(ret), ret );
-
-           delete reader;
-           reader = NULL;
-           return -1;
-       }
+    if ( ret ) {       
+      Int_t ndx = reader->GetErrorConnectionNdx();
+      if ( ndx < (Int_t) cnt) HLTError("Error establishing connection to TCP source %s:%hu: %s (%d)\n", hostnames[ndx], ports[ndx], strerror(ret), ret );
+      else HLTError("Error establishing connection to unknown source with index %d: %s (%d)\n",ndx, strerror(ret), ret );
+      
+      delete reader;
+      reader = NULL;
+      return -1;
+    }
 
-       //cout << "TRY = " << tries << " || " ;
-       tries++;
+    // -- ERROR HANDLING for HOMER (error codes and empty blocks)
+    // --------------------------------------------------------------
+    Int_t  ret1 = reader->ReadNextEvent(3000000); // timeout in microseconds (3s)
+    if ( ret1 ) {        
+      Int_t ndx = reader->GetErrorConnectionNdx();
+      
+      if ( ret1 == 111 || ret1 == 32 || ret1 == 6 ) {
+       HLTError( "Error, No Connection to source %d: %s (%d)\n", ndx, strerror(ret1), ret1 );
+       
+       delete reader;
+       reader = NULL;
+       
+       return -1; 
+      }
+      else if (ret1 == 110){
+       HLTError( "Timout occured, reading event from source %d: %s (%d)\n", ndx, strerror(ret1), ret1 );
+       
+       delete reader;
+       reader = NULL;
+       
+       return -2;
+      }
+      else if ( ret1 == 56) {
+       HLTError( "Error reading event from source %d: %s (%d) -- RETRY\n", ndx, strerror(ret1), ret1 );
+       
+       delete reader;
+       reader = NULL;
+       
+       continue; 
+      }
+      else {
+       HLTError( "General Error reading event from source %d: %s (%d)\n", ndx, strerror(ret1), ret1 );
+       
+       delete reader;
+       reader = NULL;
+       
+       return -3;
+      }
+    }
 
-       Int_t  ret1 = reader->ReadNextEvent();
-       if ( ret1 ) {
-           Int_t ndx = reader->GetErrorConnectionNdx();
-           printf( "Error reading event from source %d: %s (%d)\n", ndx, strerror(ret1), ret1 );
-           delete reader;
-           reader = NULL;
-           continue;
-       }
+    unsigned long blockCnt = reader->GetBlockCnt();  
 
-       unsigned long blockCnt = reader->GetBlockCnt();  // ####
-#if DEBUG
-       printf( "Event 0x%016LX (%Lu) with %lu blocks\n", (ULong64_t)reader->GetEventID(), (ULong64_t)reader->GetEventID(), blockCnt );
-#endif
-       if (blockCnt == 0){
-           delete reader;
-           reader = NULL;
-           continue;
-       }
-       
-       fReader = (void*) reader;
-
-       // Switch on the Display parts according what data types are present
-       for ( unsigned long i = 0; i < blockCnt; i++ ) {
-           char tmp1[9];
-           memset( tmp1, 0, 9 );
-           void *tmp11 = tmp1;
-           ULong64_t* tmp12 = (ULong64_t*)tmp11;
-           *tmp12 = reader->GetBlockDataType( i );
-           if (!strcmp(tmp1,padrowID)) fExistsRawData = kTRUE;
-           if (!strcmp(tmp1,spptID)) fExistsClusterData = kTRUE;
-           if (!strcmp(tmp1,trkID)) fExistsTrackData = kTRUE;            
-       }
+    HLTDebug( "Event 0x%016LX (%Lu) with %lu blocks\n", (ULong64_t)reader->GetEventID(), (ULong64_t)reader->GetEventID(), blockCnt );
 
-       break;
+    if (blockCnt == 0){
+      delete reader;
+      reader = NULL;
+      continue;
     }
-    fConnect = kTRUE;  
-
-    // INITIALIZE TPC DISPLAY Classes  -- IMPORTANT... don't change the order of them
-    fDisplay3D = new AliHLTTPCDisplay3D(this, gfile);
-    if (ExistsRawData()){
-       fDisplayPadRow = new AliHLTTPCDisplayPadRow(this);
-       fDisplayPad = new AliHLTTPCDisplayPad(this);
-       fDisplayFront = new AliHLTTPCDisplayFront(this);
+    
+    // SWITCH on the Display parts according what DATATAYPES are present
+    // ---------------------------------------------------------------------
+    for ( unsigned long i = 0; i < blockCnt; i++ ) {
+      char tmp1[9];
+      memset( tmp1, 0, 9 );
+      void *tmp11 = tmp1;
+      ULong64_t* tmp12 = (ULong64_t*)tmp11;
+      *tmp12 = reader->GetBlockDataType( i );
+      cout << "XXX=" << tmp1 << endl;
+      if (!strcmp(tmp1,padrowID)) fExistsRawData = kTRUE;
+      else if (!strcmp(tmp1,spptID)) fExistsClusterData = kTRUE;
+      else if (!strcmp(tmp1,trkID)) fExistsTrackData = kTRUE;            
     }
+  
+    // -- Set reader and eventID
+    // -------------------------------
+    fEventID = (ULong64_t)reader->GetEventID();
+    fReader = (void*) reader;
+    fConnect = kTRUE; 
+
+    break; // leave while(1), if connected to source
+  }
 
-    if (ExistsClusterData()){
-       fDisplayCharge = new AliHLTTPCDisplayCharge(this);
-    }
+  
+  // -- Initialize TPC Display Classes  -- IMPORTANT... don't change the order of them
+  //    Check if necessary data types are present
+  // ------------------------------------------------------------------------------------
+  fDisplay3D = new AliHLTTPCDisplay3D(this, gfile);
+  
+  if (ExistsRawData()){
+    fDisplayPadRow = new AliHLTTPCDisplayPadRow(this);
+    fDisplayPad = new AliHLTTPCDisplayPad(this);
+    fDisplayFront = new AliHLTTPCDisplayFront(this);
+  }
+  
+  if (ExistsClusterData()){
+    fDisplayCharge = new AliHLTTPCDisplayCharge(this);
+  }
+  
+  if (ExistsTrackData() && ExistsClusterData() ){
+    fDisplayResiduals = new AliHLTTPCDisplayResiduals(this);
+  }
 
-    if (ExistsTrackData() && ExistsClusterData() ){
-       fDisplayResiduals = new AliHLTTPCDisplayResiduals(this);
-    }
+  return 0;
 
-    return 0;
 #else
-    HLTFatal("HOMER raeder not available during package configuration, libAliHLTTPCDisplay compiled without HOMER support");
-    return -EFAULT;
+    HLTFatal("HOMER reader not available");
 #endif // defined(HAVE_HOMERREADER) 
 }
 
 //____________________________________________________________________________________________________
-void AliHLTTPCDisplayMain::ReadData(Bool_t nextSwitch){
+Int_t AliHLTTPCDisplayMain::Disconnect(){
 #if defined(HAVE_HOMERREADER) 
     // READ CLUSTER and TRACK data
     HOMERReader* reader = (HOMERReader*)fReader;
 
-    for(Int_t ii=0;ii<36;ii++) fTracksPerSlice[ii] = 0;
+    if (reader)
+      delete reader;
+    fReader = NULL;
 
-    // -- input datatypes , reverse
-    Char_t* spptID="SRETSULC";
-    Char_t* trkID = "SGESKART";
-    Int_t ret;
-    ULong_t blk;
+#else
+    HLTFatal("HOMER raeder not available");
+#endif // defined(HAVE_HOMERREADER) 
 
-    if (nextSwitch) {
-       while(1){
-           ret = reader->ReadNextEvent();
-           
-           if ( ret ) {
-               Int_t ndx = reader->GetErrorConnectionNdx();
-               printf( "------------ TRY AGAIN --------------->Error reading event from source %d: %s (%d)\n", ndx, strerror(ret), ret );
-               continue; 
-           }
-           break;
-       }
-    }
+    return 0;
+}
 
-    ULong_t blockCnt = reader->GetBlockCnt();
-#if DEBUG
-    printf( "Event 0x%016LX (%Lu) with %lu blocks\n", (ULong64_t)reader->GetEventID(), (ULong64_t)reader->GetEventID(), blockCnt );
-#endif    
-    for ( ULong_t i = 0; i < blockCnt; i++ ) {
-       Char_t tmp1[9], tmp2[5];
-       memset( tmp1, 0, 9 );
-       memset( tmp2, 0, 5 );
-       void *tmp11 = tmp1;
-       ULong64_t* tmp12 = (ULong64_t*)tmp11;
-       *tmp12 = reader->GetBlockDataType( i );
-       void *tmp21 = tmp2;
-       ULong_t* tmp22 = (ULong_t*)tmp21;
-       *tmp22 = reader->GetBlockDataOrigin( i );
-#if DEBUG
-       printf( "Block %lu length: %lu - type: %s - origin: %s\n",i, reader->GetBlockDataLength( i ), tmp1, tmp2 );
-#endif
-    }
-    
-    //--------------------------------------------------------------------------------------------
-    // READ CLUSTER DATA
-    //-------------------------------------------------------------------------------------------- 
-    blk = reader->FindBlockNdx( spptID, " CPT",0xFFFFFFFF );
-    
-    while ( blk != ~(ULong_t)0 ) {         
-#if DEBUG
-       printf( "Found clusters block %lu\n", blk );
-#endif
-       const AliHLTTPCClusterData* clusterData = (const AliHLTTPCClusterData*)reader->GetBlockData( blk );
-       if ( !clusterData ) {
-#if DEBUG
-           printf( "No track data for block %lu\n", blk );
-#endif
-           continue;
-       }
-       
-       ULong_t spec = reader->GetBlockDataSpec( blk );
-       Int_t patch = AliHLTTPCDefinitions::GetMinPatchNr( spec );
-       Int_t slice = AliHLTTPCDefinitions::GetMinSliceNr( spec );
-#if DEBUG
-       printf( "%lu Clusters found for slice %u - patch %u\n", clusterData->fSpacePointCnt, slice, patch );
-#endif 
-       void* tmp30 = (void*)clusterData;
-       Byte_t* tmp31 = (Byte_t*)tmp30;
-       ULong_t offset;
-       offset = sizeof(clusterData->fSpacePointCnt);
-       if ( offset <= reader->GetBlockTypeAlignment( blk, 1 ) ) offset = reader->GetBlockTypeAlignment( blk, 1 );
-       tmp31 += offset;
-       tmp30 = tmp31;
-       AliHLTTPCSpacePointData* tmp32 = (AliHLTTPCSpacePointData*)tmp30;
-       
-       SetupCluster( slice, patch, clusterData->fSpacePointCnt, tmp32 );
-       
-       blk = reader->FindBlockNdx( spptID, " CPT", 0xFFFFFFFF, blk+1 );
-    }
 
-    //--------------------------------------------------------------------------------------------
-    // READ TRACKS
-    //-------------------------------------------------------------------------------------------- 
-    if ( fTracks ) delete fTracks; 
-    fTracks = new AliHLTTPCTrackArray;
-    
-    blk = reader->FindBlockNdx( trkID, " CPT", 0xFFFFFFFF );
-       
-    while ( blk != ~(ULong_t)0 ) {
-#if DEBUG
-       printf( "Found tracks in block %lu\n", blk );
-#endif
-       const AliHLTTPCTrackletData* trackData = (const AliHLTTPCTrackletData*)reader->GetBlockData( blk );
-       if ( !trackData ) {
-#if DEBUG
-           printf( "No track data for block %lu\n", blk );
-#endif
-           continue;
-       }
-       
-       ULong_t spec = reader->GetBlockDataSpec( blk ); 
-       Int_t slice = AliHLTTPCDefinitions::GetMinSliceNr( spec );  
-#if DEBUG
-       Int_t patchmin = AliHLTTPCDefinitions::GetMinPatchNr( spec );
-       Int_t patchmax = AliHLTTPCDefinitions::GetMaxPatchNr( spec );
+//____________________________________________________________________________________________________
+Int_t AliHLTTPCDisplayMain::ReadData(Bool_t nextSwitch){
+// READ CLUSTER and TRACK data
 
-       printf( "%lu tracks found for slice %u - patch %u-%u\n", trackData->fTrackletCnt, slice, patchmin, patchmax );
-#endif 
-       fTracksPerSlice[slice] = trackData->fTrackletCnt; // Fill number if tracks per slice
-       
-       AliHLTTPCTrackSegmentData* tmp42 = (AliHLTTPCTrackSegmentData*) &(trackData->fTracklets[0]);
-       fTracks->FillTracks( trackData->fTrackletCnt, tmp42, slice );
-       
-       blk = reader->FindBlockNdx( trkID, " CPT", 0xFFFFFFFF, blk+1 ); 
-    }
+#if defined(HAVE_HOMERREADER) 
+  HOMERReader* reader = (HOMERReader*)fReader;
+  Char_t* spptID="SRETSULC";       // CLUSTERS
+  Char_t* trkID = "SGESKART";      // TRAKSEGS
+
+  // -- reset TracksPerSlice Array
+  for(Int_t ii=0;ii<36;ii++) fTracksPerSlice[ii] = 0;
+
+  Int_t ret;
+  ULong_t blk;
+
+  // -- READ next event data and ERROR HANDLING for HOMER (error codes and empty blocks)
+  // ---------------------------------------------------------------------------------------
+  if (nextSwitch) {
     
-    SetupTracks();  
+    while(1){
+      ret = reader->ReadNextEvent();
+      
+      if ( ret == 111 || ret == 32 || ret == 6 ) {
+       Int_t ndx = reader->GetErrorConnectionNdx();
+       HLTError( "Error, No Connection to source %d: %s (%d)\n", ndx, strerror(ret), ret );
+       return -1; 
+      }
+      else if ( ret == 110 ) {
+       Int_t ndx = reader->GetErrorConnectionNdx();
+       HLTError( "Timout occured, reading event from source %d: %s (%d)\n", ndx, strerror(ret), ret );
+       return -2; 
+      }
+      else if ( ret == 56) {
+       Int_t ndx = reader->GetErrorConnectionNdx();
+       HLTError( "Error reading event from source %d: %s (%d) -- RETRY\n", ndx, strerror(ret), ret );
+       continue; 
+      }
+      else if ( ret ) {
+       Int_t ndx = reader->GetErrorConnectionNdx();
+       HLTError( "General Error reading event from source %d: %s (%d)\n", ndx, strerror(ret), ret );
+       return -3;
+      }
+      else {
+       break;
+      }
+    }
+  } // end if (nextSwitch)
+
+  // -- Set blockCnt and eventID
+  // -------------------------------
+  ULong_t blockCnt = reader->GetBlockCnt();
+  fEventID = (ULong64_t)reader->GetEventID();
+
+  HLTDebug( "Event 0x%016LX (%Lu) with %lu blocks\n", (ULong64_t)reader->GetEventID(), (ULong64_t)reader->GetEventID(), blockCnt );
+
+  // Loop for Debug only
+  for ( ULong_t i = 0; i < blockCnt; i++ ) {
+    Char_t tmp1[9], tmp2[5];
+    memset( tmp1, 0, 9 );
+    memset( tmp2, 0, 5 );
+    void *tmp11 = tmp1;
+    ULong64_t* tmp12 = (ULong64_t*)tmp11;
+    *tmp12 = reader->GetBlockDataType( i );
+    void *tmp21 = tmp2;
+    ULong_t* tmp22 = (ULong_t*)tmp21;
+    *tmp22 = reader->GetBlockDataOrigin( i );
+
+    HLTDebug( "Block %lu length: %lu - type: %s - origin: %s\n",i, reader->GetBlockDataLength( i ), tmp1, tmp2 );
+  } // end for ( ULong_t i = 0; i < blockCnt; i++ ) {
+
+
+  // -- READ RAW DATA
+  //---------------------
+  ReadRawData();
+  
+  // -- READ CLUSTER DATA
+  //-------------------------
+  ReadClusterData();
+
+  // -- READ TRACKS
+  //-------------------
+  ReadTrackData();
+
 #else
-    HLTFatal("HOMER raeder not available during package configuration, libAliHLTTPCDisplay compiled without HOMER support");
+  HLTFatal("HOMER raeder not available");
 #endif // defined(HAVE_HOMERREADER) 
+
+  return 0;
 }
 
 //____________________________________________________________________________________________________
-void AliHLTTPCDisplayMain::DisplayEvent(){
+void AliHLTTPCDisplayMain::DisplayEvent(Bool_t newRawSlice){
 #if defined(HAVE_HOMERREADER) 
     HOMERReader* reader = (HOMERReader*)fReader;
 
@@ -446,6 +452,12 @@ void AliHLTTPCDisplayMain::DisplayEvent(){
        char* rawID = "KPWR_LDD";
        Int_t padrowpatch =  AliHLTTPCTransform::GetPatch(fPadRow);
        Int_t maxpadrowpatch =  padrowpatch;
+
+
+       if (newRawSlice) {
+         printf("=!=!=!=!=!= READ NEW ARRAY!\n");
+         ReadRawData();
+       }
        
        if (fPadRow == 30 || fPadRow == 90 || fPadRow == 139) maxpadrowpatch++;
 
@@ -457,6 +469,14 @@ void AliHLTTPCDisplayMain::DisplayEvent(){
            blk = reader->FindBlockNdx( rawID, " CPT", rawSpec );       
 
            if ( ~(unsigned long)0 != blk ){
+
+             // Check for corrupt data
+             AliHLTUInt64_t corruptFlag = reader->GetBlockStatusFlags( blk );
+             if (corruptFlag & 0x00000001) {
+               LOG(AliHLTTPCLog::kError,"AliHLTTPCDisplayMain::ReadData","Block status flags") << "Data block is corrupt"<<ENDLOG; 
+               continue;
+             }
+
 #if DEBUG
                printf( "Raw Data found for slice %u/patch %u\n", fSlicePadRow, patch );
 #endif
@@ -472,6 +492,98 @@ void AliHLTTPCDisplayMain::DisplayEvent(){
            }
        }
 
+#if 0
+       // -- READ raw data of one sector into 3D arrays fRawData and fRawDataZeroSuppressed
+       // -------------------------------------------------------------------------------------
+       
+       // -- reset arrays
+       memset(fRawData, 0, 159*140*1024*sizeof(UInt_t));
+       memset(fRawDataZeroSuppressed, 0, 159*140*1024*sizeof(UInt_t));
+
+       // -- read raw data blocks
+       // -----------------------
+       ULong_t blk;
+       blk = reader->FindBlockNdx( rawID, " CPT",0xFFFFFFFF );
+
+       while ( blk != ~(ULong_t)0 ) {
+         
+         HLTDebug( "Found raw data block %lu\n", blk );
+
+         // -- Check for corrupt data
+         AliHLTUInt64_t corruptFlag = reader->GetBlockStatusFlags( blk );
+         if (corruptFlag & 0x00000001) {
+           HLTError( "Data block %lu is corrupt\n",blk );
+           blk = reader->FindBlockNdx( rawID, " CPT", 0xFFFFFFFF, blk+1 );
+           continue;
+         }
+
+         void* rawDataBlock = (void*) reader->GetBlockData( blk );
+         unsigned long rawDataLen = reader->GetBlockDataLength( blk );
+
+         ULong_t spec = reader->GetBlockDataSpec( blk );
+         Int_t patch = AliHLTTPCDefinitions::GetMinPatchNr( spec );
+         Int_t slice = AliHLTTPCDefinitions::GetMinSliceNr( spec );
+
+         HLTDebug( "Raw data found for slice %u - patch %u\n", slice, patch );
+
+         // -- Wrong slice for raw data 
+         if ( GetSlicePadRow() != slice) {
+           blk = reader->FindBlockNdx( rawID, " CPT", 0xFFFFFFFF, blk+1 );
+           continue;
+         } 
+
+#if defined(HAVE_TPC_MAPPING)
+
+         // -- Read data out of block
+         AliHLTTPCDigitReaderRaw digitReader(0);
+
+         // Initialize RAW DATA
+         Int_t firstRow = AliHLTTPCTransform::GetFirstRow(patch);
+         Int_t lastRow = AliHLTTPCTransform::GetLastRow(patch);
+         
+         // Outer sector, patches 2, 3, 4, 5 -  start counting in patch 2 with row 0
+         Int_t rowOffset = 0;
+         if ( patch >= 2 ) rowOffset = AliHLTTPCTransform::GetFirstRow( 2 );
+
+         // Initialize block for reading packed data
+         digitReader.InitBlock(rawDataBlock,rawDataLen,firstRow,lastRow,patch,slice);
+
+         Bool_t readValue = digitReader.Next();
+
+         if (!readValue){      
+           LOG(AliHLTTPCLog::kError,"AliHLTTPCDisplayPadRow::Fill","Read first value") << "No value in data block" << ENDLOG;
+           blk = reader->FindBlockNdx( rawID, " CPT", 0xFFFFFFFF, blk+1 );
+           continue;
+         }
+
+         // LOOP over raw data and fill arrays
+         while ( readValue ){ 
+           
+           Int_t row = digitReader.GetRow() + rowOffset;
+           Int_t pad = (Int_t) digitReader.GetPad();
+           Int_t time = (Int_t) digitReader.GetTime();
+           UInt_t signal = (UInt_t) digitReader.GetSignal();
+
+           fRawData[row][pad][time] = signal;
+           fRawDataZeroSuppressed[row][pad][time] = signal;
+           
+           // -- read next value
+           readValue = digitReader.Next();
+      
+           // -- No more value
+           if(!readValue) break; 
+         } // end  while ( readValue ){ 
+
+
+#else //! defined(HAVE_TPC_MAPPING)
+         HLTFatal("DigitReaderRaw not available - check your build");
+#endif //defined(HAVE_TPC_MAPPING)
+         
+         blk = reader->FindBlockNdx( rawID, " CPT", 0xFFFFFFFF, blk+1 );
+
+       } // end while ( blk != ~(ULong_t)0 ) {
+#endif
+
        fDisplayPad->Draw();
        fDisplayPadRow->Draw();
        fDisplayFront->Draw();
@@ -502,7 +614,7 @@ void AliHLTTPCDisplayMain::DisplayEvent(){
     // TAKE CARE !!! EXISTSxxxData() HANDLING of 3D will be done IN this class !!!
     fDisplay3D->Draw(); 
 #else
-    HLTFatal("HOMER raeder not available during package configuration, libAliHLTTPCDisplay compiled without HOMER support");
+    HLTFatal("HOMER raeder not available");
 #endif // defined(HAVE_HOMERREADER) 
 
 }
@@ -615,6 +727,333 @@ void AliHLTTPCDisplayMain::SetSliceArray() {
     }
 }
 
+//____________________________________________________________________________________________________
+void AliHLTTPCDisplayMain::ReadRawData(){
+  // -- READ raw data of one sector into 3D arrays fRawData and fRawDataZeroSuppressed
+
+  // -- reset arrays
+  memset(fRawData, 0, 159*140*1024*sizeof(UInt_t));
+  memset(fRawDataZeroSuppressed, 0, 159*140*1024*sizeof(UInt_t));
+
+#if defined(HAVE_HOMERREADER) 
+  HOMERReader* reader = (HOMERReader*)fReader;
+  
+  // -- read raw data blocks
+  // ---------------------------
+  ULong_t blk;
+  Char_t* rawID = "KPWR_LDD";    
+  blk = reader->FindBlockNdx( rawID, " CPT",0xFFFFFFFF );
+  
+  while ( blk != ~(ULong_t)0 ) {
+    HLTDebug( "Found raw data block %lu\n", blk );
+
+    // -- Check for corrupt data
+    AliHLTUInt64_t corruptFlag = reader->GetBlockStatusFlags( blk );
+    if (corruptFlag & 0x00000001) {
+      HLTError( "Data block %lu is corrupt\n",blk );
+      blk = reader->FindBlockNdx( rawID, " CPT", 0xFFFFFFFF, blk+1 );
+      continue;
+    }
+
+    void* rawDataBlock = (void*) reader->GetBlockData( blk );
+    unsigned long rawDataLen = reader->GetBlockDataLength( blk );
+    
+    ULong_t spec = reader->GetBlockDataSpec( blk );
+    Int_t patch = AliHLTTPCDefinitions::GetMinPatchNr( spec );
+    Int_t slice = AliHLTTPCDefinitions::GetMinSliceNr( spec );
+    
+    HLTDebug( "Raw data found for slice %u - patch %u\n", slice, patch );
+
+    // -- Wrong slice for raw data 
+    if ( GetSlicePadRow() != slice) {
+      blk = reader->FindBlockNdx( rawID, " CPT", 0xFFFFFFFF, blk+1 );
+      continue;
+    } 
+    
+#if defined(HAVE_TPC_MAPPING)
+
+    // -- Read data out of block
+    AliHLTTPCDigitReaderRaw digitReader(0);
+    
+    // Initialize RAW DATA
+    Int_t firstRow = AliHLTTPCTransform::GetFirstRow(patch);
+    Int_t lastRow = AliHLTTPCTransform::GetLastRow(patch);
+    
+    // Outer sector, patches 2, 3, 4, 5 -  start counting in patch 2 with row 0
+    Int_t rowOffset = 0;
+    if ( patch >= 2 ) rowOffset = AliHLTTPCTransform::GetFirstRow( 2 );
+    
+    // Initialize block for reading packed data
+    digitReader.InitBlock(rawDataBlock,rawDataLen,firstRow,lastRow,patch,slice);
+    
+    Bool_t readValue = digitReader.Next();
+
+    if (!readValue){   
+      HLTError ( "No value in data block %lu \n", blk);
+      blk = reader->FindBlockNdx( rawID, " CPT", 0xFFFFFFFF, blk+1 );
+      continue;
+    }
+
+    // -- Fill Zero Suppressed Array
+    // ---------------------------------
+
+    Int_t newRow = 0;    
+    UShort_t time=0,newTime=0;
+    UInt_t pad=0,newPad=0;
+    Int_t signal=0;
+
+    Int_t gatingGridOffset=50;
+    Int_t signalThreshold = 10;
+    AliHLTTPCPad baseline(gatingGridOffset, GetNTimeBins() );
+
+    // just to make later conversion to a list of objects easier
+    AliHLTTPCPad* pCurrentPad=NULL;
+    if ( signalThreshold >= 0) {
+      pCurrentPad=&baseline;
+      baseline.SetThreshold(signalThreshold);
+    }
+
+    while ( readValue ) { // Reads through all digits in block
+     
+      while(1){ //Loop over time bins of current pad
+       // read all the values for one pad at once to calculate the base line
+       if (pCurrentPad) {
+         
+         if (!pCurrentPad->IsStarted()) {
+           
+           HLTDebug("reading data for pad %d, padrow %d", digitReader.GetPad(), digitReader.GetRow()+rowOffset);
+           
+           pCurrentPad->SetID(digitReader.GetRow()+rowOffset,digitReader.GetPad());
+           
+           if ( (pCurrentPad->StartEvent()) >= 0) {
+             // loop over data of one pad and read it into AliHLTTPCPad class
+             do {
+               if ( (digitReader.GetRow()+rowOffset) != pCurrentPad->GetRowNumber() ) break;
+               if ( digitReader.GetPad() != pCurrentPad->GetPadNumber() ) break;
+               pCurrentPad->SetRawData( digitReader.GetTime(), digitReader.GetSignal() );
+               
+               HLTDebug("set raw data to pad: bin %d charge %d", digitReader.GetTime(), digitReader.GetSignal());
+               
+             } while ( (readValue = digitReader.Next()) != 0 );
+           }
+
+           // calculate baseline of pad
+           pCurrentPad->CalculateBaseLine( GetNTimeBins() / 2);
+           
+           if ( pCurrentPad->Next(kTRUE/*do zero suppression*/) == 0 ) {
+             HLTDebug("no data available after zero suppression");
+             
+             pCurrentPad->StopEvent();
+             pCurrentPad->ResetHistory();
+             break;
+           }
+
+           Int_t time = pCurrentPad->GetCurrentPosition();
+           if ( time > pCurrentPad->GetSize() ) {
+             HLTError("invalid time bin for pad");
+             break;
+           }     
+         } // end - if (!pCurrentPad->IsStarted()) {
+       } // end - if (pCurrentPad) {
+       
+       if (pCurrentPad) {
+         Float_t occupancy=pCurrentPad->GetOccupancy();
+         if ( occupancy < 0.01 ) {
+           signal = pCurrentPad->GetCorrectedData();
+         } 
+         else {
+           signal = 0;
+           HLTInfo("ignoring pad %d with occupancy level %f %%", pCurrentPad->GetPadNumber(), occupancy);
+         }
+         //      signal = pCurrentPad->GetCorrectedData();
+       } else {
+         signal = digitReader.GetSignal();
+       }
+
+       fRawDataZeroSuppressed[ pCurrentPad->GetRowNumber() ][ pCurrentPad->GetPadNumber() ][ pCurrentPad->GetCurrentPosition() ] = (UInt_t)signal;
+
+       
+       HLTDebug("get next charge value: position %d charge %d", time, signal);
+       
+       if( time >= AliHLTTPCTransform::GetNTimeBins() ){
+         HLTWarning("Timebin (%d) out of range (%d)", time, AliHLTTPCTransform::GetNTimeBins());
+         break;
+       }
+         
+       if (pCurrentPad) {
+       
+         if( (pCurrentPad->Next(kTRUE/*do zero suppression*/)) == 0 ) {
+           pCurrentPad->StopEvent();
+           pCurrentPad->ResetHistory();
+
+           if(readValue) {
+             newPad = digitReader.GetPad();
+             newTime = digitReader.GetTime();
+             newRow = digitReader.GetRow() + rowOffset;
+           }
+           break;
+         }
+         
+         newPad=pCurrentPad->GetPadNumber();
+         newTime=pCurrentPad->GetCurrentPosition();
+         newRow=pCurrentPad->GetRowNumber();
+       } 
+       else {
+         
+         readValue = digitReader.Next();
+         
+         //Check where to stop:
+         if(!readValue) break; //No more value
+         
+         newPad = digitReader.GetPad();
+         newTime = digitReader.GetTime();
+         newRow = digitReader.GetRow() + rowOffset;
+       }
+       
+       if(newPad != pad) break; //new pad
+       if(newTime != time+1) break; //end of sequence
+       
+       time = newTime;
+       
+      } // end - while(1){ // Loop over time bins of current pad
+
+      if ( !readValue ) break;
+
+    } // end  while ( readValue ) {
+
+    // -- END ZERO SUPPRESSION
+
+    // Rewind block for reading packed data
+    digitReader.InitBlock(rawDataBlock,rawDataLen,firstRow,lastRow,patch,slice);
+
+    // -- Fill Raw Array
+    // ---------------------
+    readValue = digitReader.Next();
+    
+    // LOOP over raw data and fill arrays
+    while ( readValue ){ 
+           
+      Int_t row = digitReader.GetRow() + rowOffset;
+      Int_t pad = (Int_t) digitReader.GetPad();
+      Int_t time = (Int_t) digitReader.GetTime();
+      UInt_t signal = (UInt_t) digitReader.GetSignal();
+
+      fRawData[row][pad][time] = signal;
+           
+      // -- read next value
+      readValue = digitReader.Next();
+      
+      // -- No more value
+      if(!readValue) break; 
+
+    } // end  while ( readValue ){ 
+
+#else //! defined(HAVE_TPC_MAPPING)
+    HLTFatal("DigitReaderRaw not available - check your build");
+#endif //defined(HAVE_TPC_MAPPING)
+         
+    blk = reader->FindBlockNdx( rawID, " CPT", 0xFFFFFFFF, blk+1 );
+    
+  } // end while ( blk != ~(ULong_t)0 ) {
+  
+#else
+  HLTFatal("HOMER raeder not available");
+#endif // defined(HAVE_HOMERREADER) 
+  
+}
+
+//____________________________________________________________________________________________________
+void AliHLTTPCDisplayMain::ReadClusterData(){
+ // -- READ cluster data 
+#if defined(HAVE_HOMERREADER) 
+  HOMERReader* reader = (HOMERReader*)fReader;
+
+  ULong_t blk;
+  Char_t* spptID="SRETSULC";       // CLUSTERS
+  blk = reader->FindBlockNdx( spptID, " CPT",0xFFFFFFFF );
+   
+  while ( blk != ~(ULong_t)0 ) {           
+    HLTDebug( "Found clusters block %lu\n", blk );
+    
+    const AliHLTTPCClusterData* clusterData = (const AliHLTTPCClusterData*)reader->GetBlockData( blk );
+    if ( !clusterData ) {
+      HLTError( "No track data for block %lu\n", blk );
+      blk = reader->FindBlockNdx( spptID, " CPT", 0xFFFFFFFF, blk+1 );
+      continue;
+    }
+       
+    ULong_t spec = reader->GetBlockDataSpec( blk );
+    Int_t patch = AliHLTTPCDefinitions::GetMinPatchNr( spec );
+    Int_t slice = AliHLTTPCDefinitions::GetMinSliceNr( spec );
+
+    HLTDebug( "%lu Clusters found for slice %u - patch %u\n", clusterData->fSpacePointCnt, slice, patch );
+
+    void* tmp30 = (void*)clusterData;
+    Byte_t* tmp31 = (Byte_t*)tmp30;
+    ULong_t offset;
+    offset = sizeof(clusterData->fSpacePointCnt);
+    if ( offset <= reader->GetBlockTypeAlignment( blk, 1 ) ) offset = reader->GetBlockTypeAlignment( blk, 1 );
+    tmp31 += offset;
+    tmp30 = tmp31;
+    AliHLTTPCSpacePointData* tmp32 = (AliHLTTPCSpacePointData*)tmp30;
+       
+    SetupCluster( slice, patch, clusterData->fSpacePointCnt, tmp32 );
+    
+    blk = reader->FindBlockNdx( spptID, " CPT", 0xFFFFFFFF, blk+1 );
+  }
+  
+#else
+  HLTFatal("HOMER raeder not available");
+#endif // defined(HAVE_HOMERREADER) 
+}
+//____________________________________________________________________________________________________
+void AliHLTTPCDisplayMain::ReadTrackData(){
+  // -- READ track data
+  
+  if ( fTracks ) delete fTracks; 
+  fTracks = new AliHLTTPCTrackArray;
+  
+#if defined(HAVE_HOMERREADER) 
+  HOMERReader* reader = (HOMERReader*)fReader;
+  
+  ULong_t blk;
+  Char_t* trkID = "SGESKART";      // TRAKSEGS
+  blk = reader->FindBlockNdx( trkID, " CPT", 0xFFFFFFFF );
+  
+  while ( blk != ~(ULong_t)0 ) {
+
+    HLTDebug( "Found tracks in block %lu\n", blk );
+
+    const AliHLTTPCTrackletData* trackData = (const AliHLTTPCTrackletData*)reader->GetBlockData( blk );
+
+    if ( !trackData ) {
+      HLTError( "No track data for block %lu\n", blk );
+      blk = reader->FindBlockNdx( trkID, " CPT", 0xFFFFFFFF, blk+1 );
+      continue;
+    }
+    
+    ULong_t spec = reader->GetBlockDataSpec( blk );    
+    Int_t slice = AliHLTTPCDefinitions::GetMinSliceNr( spec );  
+    Int_t patchmin = AliHLTTPCDefinitions::GetMinPatchNr( spec );
+    Int_t patchmax = AliHLTTPCDefinitions::GetMaxPatchNr( spec );
+    
+    HLTDebug( "%lu tracks found for slice %u - patch %u-%u\n", trackData->fTrackletCnt, slice, patchmin, patchmax );
+
+    fTracksPerSlice[slice] = trackData->fTrackletCnt; // Fill number if tracks per slice
+       
+    AliHLTTPCTrackSegmentData* tmp42 = (AliHLTTPCTrackSegmentData*) &(trackData->fTracklets[0]);
+    fTracks->FillTracks( trackData->fTrackletCnt, tmp42, slice );
+    
+    blk = reader->FindBlockNdx( trkID, " CPT", 0xFFFFFFFF, blk+1 );    
+  }
+    
+  SetupTracks(); 
+
+#else
+  HLTFatal("HOMER raeder not available");
+#endif // defined(HAVE_HOMERREADER) 
+}
+
 //----------------------------------------------------------------------------------------------------
 //                 GETTER
 //____________________________________________________________________________________________________
@@ -666,3 +1105,5 @@ void AliHLTTPCDisplayMain::ExecPadEvent(Int_t event, Int_t px, Int_t py, TObject
         fPadCallback(fPt2Gui, binx);
   }
 }
+
+
index a281507..5e0aaac 100644 (file)
@@ -33,74 +33,100 @@ class AliHLTTPCDisplayFront;
 class AliHLTTPCDisplayMain : public TObject , public AliHLTLogging {
 
  public:
-    AliHLTTPCDisplayMain(void* pt2GUI, void (*pt2Function)(void*, Int_t));
-    virtual ~AliHLTTPCDisplayMain();
+  AliHLTTPCDisplayMain(void* pt2GUI, void (*pt2Function)(void*, Int_t));
+  virtual ~AliHLTTPCDisplayMain();
+  
+  Int_t Connect( unsigned int cnt, const char** hostnames, unsigned short* ports,Char_t *gfile="$(ALIHLT_BASEDIR)/geo/alice.geom" );
+  Int_t Disconnect();
+  
+  Int_t ReadData(Bool_t nextSwitch = kTRUE);
+  void ReadRawData();
+  void ReadClusterData();
+  void ReadTrackData();
+
+  void DisplayEvent(Bool_t newRawSlice = kFALSE);
+  void SaveHistograms();
+
+  /*
+   * **********************************
+   *              SETUP
+   * **********************************
+   */
+  void SetupCluster(Int_t slice, Int_t patch, UInt_t nofClusters, AliHLTTPCSpacePointData* data);
+  void SetupTracks();
+
+
+  /*
+   * **********************************
+   *              SETTER
+   * **********************************
+   */
+  void SetConnectionStatus(Bool_t f) {fConnect = f;}
+
+  // canvas ----
+  void SetCanvasCharge(TCanvas *f){fCanvasCharge = f;}
+  void SetCanvasPadRow(TCanvas *f){fCanvasPadRow = f;}
+  void SetCanvasPad(TCanvas *f){fCanvasPad = f;}
+  void SetCanvas3D(TCanvas *f){fCanvas3D = f;}
+  void SetCanvasResiduals(TCanvas *f){fCanvasResiduals = f;}
+  void SetCanvasFront(TCanvas *f){fCanvasFront = f;}
+  void SetCanvasHits_S(TCanvas *f){fCanvasHits_S = f;}
+  void SetCanvasQ_Track(TCanvas *f){fCanvasQ_Track = f;}
+  void SetCanvasQ_S(TCanvas *f){fCanvasQ_S = f;}
+  void SetCanvasPadRow_Pad(TCanvas *f){fCanvasPadRow_Pad = f;}
+
+
+  // slices ----
+  void SetSlices(){fMinSlice = 0; fMaxSlice = 35; fSlicePair = kFALSE; SetSliceArray();}
+  void SetSlices(Int_t s){fMinSlice = s; fMaxSlice = s; fSlicePair = kFALSE; SetSliceArray();}
+  void SetSlices(Int_t mins, Int_t maxs){fMinSlice = mins; fMaxSlice = maxs; fSlicePair = kFALSE; SetSliceArray();}
+  void SetSlicesPair(Int_t s){fMinSlice = s; fMaxSlice = s; fSlicePair = kTRUE; SetSliceArray();}
+  void SetSlicesPair(Int_t mins, Int_t maxs){fMinSlice = mins; fMaxSlice = maxs; fSlicePair = kTRUE; SetSliceArray();}
+  
+  // cuts ----
+  //    void SetCutHits(Int_t f){fMinHits = f;}
+  //    void SetCutPt(Float_t f){fPtThreshold = f;}
+  void SetCutHits(Int_t f){fCutHits = f;}
+  void SetCutPt(Float_t f){fCutPt = f;}
+  void SetCutPsi(Float_t f){fCutPsi = f;}
+  void SetCutLambda(Float_t f){fCutLambda = f;}
+  void SetCutS(Float_t f){fCut_S = f;}
+  void SetIncidentPadrow(Int_t f){fCutPadrow = f;}
+  
+  // 3D display ----
+  void SetInvert() {Int_t tmp = fBackColor; fBackColor = fLineColor; fLineColor = tmp; }
+  void SetKeepView(Bool_t f){fKeepView = f;} 
+  void SetSwitches(Bool_t f1, Bool_t f2, Bool_t f3, Bool_t f4) {fSwitch3DTracks = f1; fSwitch3DCluster = f2; fSwitch3DPadRow = f3; fSwitch3DGeometry = f4;} 
+  void Set3DRawSwitch(Int_t f) {fSwitch3DRaw = f;}
+  void SetTheta(Float_t f) {fTheta = f;}
+
+  // raw ----
+  void SetZeroSuppression(Bool_t f){fZeroSuppression = f;}
+  //     -- pad/padrow
+  void SetPad(Int_t f){fPad = f;}
+  void SetPadRow(Int_t f){fPadRow = f; fNPads = AliHLTTPCTransform::GetNPads(f); }
+  void SetSlicePadRow(Int_t f){fSlicePadRow = f;}
+  void SetSplitPadRow(Bool_t f){fSplitPadRow = f;}
+  //     -- front
+  void SetFrontDataSwitch(Int_t f){fFrontDataSwitch = f;}
+  void SetTimeBinMinMax(Int_t f1, Int_t f2){fTimeBinMin = f1; fTimeBinMax = f2; }
+  void SetSplitFront(Bool_t f){fSplitFront = f;}
+
+  // track ----
+  void SetSelectTrack(Int_t f) {fSelectTrack = f;}
+  void SetSelectTrackSlice(Int_t f) {fSelectTrackSlice = f;}
+  void SetSelectTrackSwitch(Bool_t f) {fSelectTrackSwitch = f;}
+  void SetSelectCluster(Int_t f) {fSelectCluster = f;}
+
+  /*
+   * **********************************
+   *              GETTER
+   * **********************************
+   */
 
-    Int_t Connect( unsigned int cnt, const char** hostnames, unsigned short* ports,Char_t *gfile="$(ALIHLT_BASEDIR)/geo/alice.geom" );
     
-    void ReadData(Bool_t nextSwitch = kTRUE);
-    void DisplayEvent();
-    void SaveHistograms();
-
-    // SETUP
-    void SetupCluster(Int_t slice, Int_t patch, UInt_t nofClusters, AliHLTTPCSpacePointData* data);
-    void SetupTracks();
-
-    // SETTER   
-    void SetConnectionStatus(Bool_t f) {fConnect = f;}
-
-    // canvas ----
-    void SetCanvasCharge(TCanvas *f){fCanvasCharge = f;}
-    void SetCanvasPadRow(TCanvas *f){fCanvasPadRow = f;}
-    void SetCanvasPad(TCanvas *f){fCanvasPad = f;}
-    void SetCanvas3D(TCanvas *f){fCanvas3D = f;}
-    void SetCanvasResiduals(TCanvas *f){fCanvasResiduals = f;}
-    void SetCanvasFront(TCanvas *f){fCanvasFront = f;}
-    void SetCanvasHits_S(TCanvas *f){fCanvasHits_S = f;}
-    void SetCanvasQ_Track(TCanvas *f){fCanvasQ_Track = f;}
-    void SetCanvasQ_S(TCanvas *f){fCanvasQ_S = f;}
-
-    // slices ----
-    void SetSlices(){fMinSlice = 0; fMaxSlice = 35; fSlicePair = kFALSE; SetSliceArray();}
-    void SetSlices(Int_t s){fMinSlice = s; fMaxSlice = s; fSlicePair = kFALSE; SetSliceArray();}
-    void SetSlices(Int_t mins, Int_t maxs){fMinSlice = mins; fMaxSlice = maxs; fSlicePair = kFALSE; SetSliceArray();}
-    void SetSlicesPair(Int_t s){fMinSlice = s; fMaxSlice = s; fSlicePair = kTRUE; SetSliceArray();}
-    void SetSlicesPair(Int_t mins, Int_t maxs){fMinSlice = mins; fMaxSlice = maxs; fSlicePair = kTRUE; SetSliceArray();}
-
-    // cuts ----
-    //    void SetCutHits(Int_t f){fMinHits = f;}
-    //    void SetCutPt(Float_t f){fPtThreshold = f;}
-    void SetCutHits(Int_t f){fCutHits = f;}
-    void SetCutPt(Float_t f){fCutPt = f;}
-    void SetCutPsi(Float_t f){fCutPsi = f;}
-    void SetCutLambda(Float_t f){fCutLambda = f;}
-    void SetCutS(Float_t f){fCut_S = f;}
-    void SetIncidentPadrow(Int_t f){fCutPadrow = f;}
-
-    void SetInvert() {Int_t tmp = fBackColor; fBackColor = fLineColor; fLineColor = tmp; }
-    void SetKeepView(Bool_t f){fKeepView = f;} 
-
-    // raw ----
-    void SetPad(Int_t f){fPad = f;}
-    void SetPadRow(Int_t f){fPadRow = f; fNPads = AliHLTTPCTransform::GetNPads(f); }
-    void SetSlicePadRow(Int_t f){fSlicePadRow = f;}
-    void SetTimebin(Int_t f){fTimebin = f;}
-
-    void SetAllTimebins(Bool_t f){fAllTimebins = f;}
-    void SetSplitPadRow(Bool_t f){fSplitPadRow = f;}
-
-    void SetSelectTrack(Int_t f) {fSelectTrack = f;}
-    void SetSelectTrackSlice(Int_t f) {fSelectTrackSlice = f;}
-    void SetSelectTrackSwitch(Bool_t f) {fSelectTrackSwitch = f;}
-    void SetSelectCluster(Int_t f) {fSelectCluster = f;}
-
-    void SetSwitches(Bool_t f1, Bool_t f2, Bool_t f3, Bool_t f4) {fSwitch3DTracks = f1; fSwitch3DCluster = f2; fSwitch3DPadRow = f3; fSwitch3DGeometry = f4;} 
-
-    void SetTheta(Float_t f) {fTheta = f;}
-
-
-    // GETTER
     Bool_t GetConnectionStatus() {return fConnect;}
+    ULong64_t GetEventID() {return fEventID;}
 
     AliHLTTPCSpacePointData* GetSpacePointDataPointer(Int_t slice,Int_t patch){return fClusters[slice][patch];}
     AliHLTTPCTrackArray* GetTrackArrayPointer() {return fTracks;}
@@ -136,15 +162,23 @@ class AliHLTTPCDisplayMain : public TObject , public AliHLTLogging {
     Int_t GetSelectTrackSlice() {return fSelectTrackSlice;}
 
     Int_t GetGlobalTrack(Int_t slice);
-
+  
+    // raw ----
+    Bool_t GetZeroSuppression(){return fZeroSuppression;}
+    //     -- pad/padrow
     Int_t GetPad(){return fPad;}
+    Int_t GetNPads(){return fNPads;}
     Int_t GetPadRow(){return fPadRow;}
     Int_t GetSlicePadRow(){return fSlicePadRow;}
     Bool_t GetSplitPadRow(){return fSplitPadRow;}
+    //     -- front
+    Int_t GetNTimeBins(){return fgNTimeBins;}
+    Int_t GetFrontDataSwitch(){return fFrontDataSwitch;}
+    Int_t GetTimeBinMin(){return fTimeBinMin;}
+    Int_t GetTimeBinMax(){return fTimeBinMax;}
+    Bool_t GetSplitFront(){return fSplitFront;}
+  
 
-    Int_t GetNPads(){return fNPads;}
-    Int_t GetTimebin(){return fTimebin;}
-    Bool_t GetAllTimebins(){return fAllTimebins;}
 
     Int_t GetLineColor(){return fLineColor;}
     Int_t GetBackColor(){return fBackColor;}
@@ -156,12 +190,13 @@ class AliHLTTPCDisplayMain : public TObject , public AliHLTLogging {
     Bool_t Get3DSwitchCluster() {return fSwitch3DCluster;}
     Bool_t Get3DSwitchPadRow() {return fSwitch3DPadRow;}
     Bool_t Get3DSwitchGeometry() {return fSwitch3DGeometry;}
+    Int_t  Get3DSwitchRaw() {return fSwitch3DRaw;}
 
     Int_t GetTrackParamNHits(){ return fTrackParam.nHits;}
-
+    /*    
 #if 0
     Char_t GetTrackParamSlice(){ return Char_t GetTrackParamId();
-    Char_t GetTrackParamKappa());
+      Char_t GetTrackParamKappa());
     Char_t GetTrackParamPt());
 Char_t GetTrackParamNHits());
 Char_t GetTrackParamCharge());
@@ -170,7 +205,9 @@ Char_t GetTrackParamPhi0());
 Char_t GetTrackParamPsi());
 Char_t GetTrackParamLambda());
 Char_t GetTrackParamBfield());
-#endif
+    #endif
+    */
+
     // EXISTS
     Bool_t ExistsRawData() {return fExistsRawData;}   
     Bool_t ExistsClusterData() {return fExistsClusterData;}   
@@ -198,14 +235,25 @@ Char_t GetTrackParamBfield());
        Double_t s;
     };
     
+    void* fReader;                 // really HOMERReader*
+
+    UInt_t fRawData[159][140][1024];                    // Raw Data of one Slice
+    UInt_t fRawDataZeroSuppressed[159][140][1024];      // Raw Data of one Slice zero suppressed
+
     AliHLTTPCTrackParameter fTrackParam;
 
 // ---------------------------------------------------
  private:
-    AliHLTTPCDisplayMain(const AliHLTTPCDisplayMain &/*d*/):TObject(), AliHLTLogging(){;}
+    AliHLTTPCDisplayMain(const AliHLTTPCDisplayMain &/*d*/):TObject(){;}
     AliHLTTPCDisplayMain& operator=(const AliHLTTPCDisplayMain &/*d*/){return *this;}
-   
-    void SetSliceArray();
+      
+    void SetSliceArray();          // Fill Array with slices which 
+
+    // ** global constants **
+    Int_t fgNTimeBins;             // Number of TimeBins 
+
+    // **  HOMER parameter / connection / data exist **
+    ULong64_t fEventID;            // Event ID
 
     Bool_t fConnect;               // Connection status
   
@@ -213,25 +261,66 @@ Char_t GetTrackParamBfield());
     Bool_t fExistsClusterData;     // Cluster data present
     Bool_t fExistsTrackData;       // Track data present
 
-    void* fReader;                 // really HOMERReader*
+    // ** pointer to display classes **
+    AliHLTTPCDisplayCharge* fDisplayCharge; 
+    AliHLTTPCDisplayPadRow* fDisplayPadRow;
+    AliHLTTPCDisplayPad* fDisplayPad;
+    AliHLTTPCDisplay3D* fDisplay3D;
+    AliHLTTPCDisplayResiduals* fDisplayResiduals;
+    AliHLTTPCDisplayFront * fDisplayFront;
+
+    // ** pointer to canvases in GUI ** 
+    TCanvas * fCanvasCharge;
+    TCanvas * fCanvasPadRow;
+    TCanvas * fCanvasPad;
+    TCanvas * fCanvas3D;
+    TCanvas * fCanvasResiduals;
+    TCanvas * fCanvasFront;
+    TCanvas * fCanvasHits_S;
+    TCanvas * fCanvasQ_Track;
+    TCanvas * fCanvasQ_S;
+    TCanvas * fCanvasPadRow_Pad;
 
     Int_t fTracksPerSlice[36];     // TrackCount per slice
 
+    // ** cluster / tarck container **
     AliHLTTPCSpacePointData *fClusters[36][6]; 
     AliHLTTPCTrackArray *fTracks; 
     
     UInt_t fNcl[36][6];            // Number of cluster
 
+    // ** selected selected slice(s) **
     Int_t fMinSlice;               // Min slice
     Int_t fMaxSlice;               // Max slice
     Bool_t fSlicePair;             // Pair of slices;
     Bool_t fSliceArray[36];        // Array if slice should be drawn or not
 
+    // ** select type of clusters **
     Int_t fSelectCluster;          // select all=0, used=1, unused=2 cluster
 
-    // cuts ----
-//    Int_t fMinHits;                // minimum cluster per track
-//    Float_t fPtThreshold;          // pt threshold for tracks
+    // ** raw data variables **
+    Bool_t fZeroSuppression;       // enable zero suppression
+    //     -- pad/padrow
+    Int_t fPad;                    // pad
+    Int_t fNPads;                  // number of pads in row
+    Int_t fPadRow;                 // padrow
+    Int_t fSlicePadRow;            // slice where padrow is in
+    Bool_t fSplitPadRow;           // Split PadRow Canvas
+    //     -- front
+    Int_t fFrontDataSwitch;        // select average/sum/maximum
+    Int_t fTimeBinMin;             // min TimeBin
+    Int_t fTimeBinMax;             // max TimeBin
+    Bool_t fSplitFront;            // Split Front Canvas
+
+  
+    // ** select tracks **
+    Bool_t fSelectTrackSwitch;     // switch ti single track mode
+    Int_t fSelectTrack;            // select single track
+    Int_t fSelectTrackSlice;       // select slice for single track
+
+
+    // ** cuts on tracks **
     Int_t fCutHits;
     Float_t fCutPt;
     Float_t fCutPsi;
@@ -239,47 +328,21 @@ Char_t GetTrackParamBfield());
     Float_t fCut_S;
     Int_t fCutPadrow;
 
+    // ** "keepview", angles and colors for 3D view **
+    Bool_t fKeepView;              // Keep View when redisplaying
+
+    Float_t fTheta;
+    Float_t fPhi;
+
     Int_t fBackColor;              // Background color
     Int_t fLineColor;              // Line color
-    Bool_t fKeepView;              // Keep View when redisplaying
 
+    // ** 3D switches **
     Bool_t fSwitch3DCluster;
     Bool_t fSwitch3DTracks;
     Bool_t fSwitch3DPadRow;
     Bool_t fSwitch3DGeometry;
-
-    Int_t fPad;                    // pad
-    Int_t fPadRow;                 // padrow
-    Int_t fSlicePadRow;            // slice where padrow is in
-    Int_t fNPads;                  // number of pads in padrow
-    Int_t fTimebin;
-
-    Bool_t fAllTimebins;
-    Bool_t fSplitPadRow;
-
-    Bool_t fSelectTrackSwitch;     // switch ti single track mode
-    Int_t fSelectTrack;            // select single track
-    Int_t fSelectTrackSlice;       // select slice for single track
-
-    Float_t fTheta;
-    Float_t fPhi;
-
-    AliHLTTPCDisplayCharge* fDisplayCharge; 
-    AliHLTTPCDisplayPadRow* fDisplayPadRow;
-    AliHLTTPCDisplayPad* fDisplayPad;
-    AliHLTTPCDisplay3D* fDisplay3D;
-    AliHLTTPCDisplayResiduals* fDisplayResiduals;
-    AliHLTTPCDisplayFront * fDisplayFront;
-
-    TCanvas * fCanvasCharge;
-    TCanvas * fCanvasPadRow;
-    TCanvas * fCanvasPad;
-    TCanvas * fCanvas3D;
-    TCanvas * fCanvasResiduals;
-    TCanvas * fCanvasFront;
-    TCanvas * fCanvasHits_S;
-    TCanvas * fCanvasQ_Track;
-    TCanvas * fCanvasQ_S;
+    Int_t fSwitch3DRaw;    
 
     ClassDef(AliHLTTPCDisplayMain,0) //Display class
 };
index 17d3816..107484c 100644 (file)
@@ -32,8 +32,6 @@
 #include "AliHLTTPCClusterDataFormat.h"
 #include "AliHLTTPCLogging.h"
 #include "AliHLTTPCTransform.h"
-#include "AliHLTTPCDigitReaderPacked.h"
-#include "AliHLTTPCDigitReaderRaw.h"
 
 #include "AliHLTTPCDisplayMain.h"
 #include "AliHLTTPCDisplayPad.h"
@@ -111,62 +109,46 @@ void AliHLTTPCDisplayPad::Save(){
 
 //____________________________________________________________________________________________________
 void AliHLTTPCDisplayPad::Fill(Int_t patch, ULong_t dataBlock, ULong_t dataLen){
-    // Fill Pad Histogram
-
-#if defined(HAVE_TPC_MAPPING)    
-    AliHLTTPCDigitReaderRaw digitReader(0);
-
-    bool readValue = true;
-    Int_t rowOffset = 0;
+  // Fill Pad Histogram
+
+  Int_t padRow = fDisplay->GetPadRow();
+  Int_t pad = fDisplay->GetPad();
+  Int_t nextPad = pad + 1;
+  Int_t prevPad = pad - 1;
+  
+  // !!
+  // !!  DO unrolling because of cache effects (avoid cache trashing) !!
+  // !!
+
+  if ( fDisplay->GetZeroSuppression() ){
+    for (Int_t timeBin=0; timeBin <= fDisplay->GetNTimeBins(); timeBin++){
+       fHistpad1->Fill( timeBin, fDisplay->fRawDataZeroSuppressed[padRow][prevPad][timeBin] );
+    } // end time
     
-    Int_t slice = fDisplay->GetSlicePadRow();
-    Int_t padRow = fDisplay->GetPadRow();
-    Int_t pad = fDisplay->GetPad();
-
-    // Initialize RAW DATA
-    Int_t firstRow = AliHLTTPCTransform::GetFirstRow(patch);
-    Int_t lastRow = AliHLTTPCTransform::GetLastRow(patch);
-
-    // Outer sector, patches 2, 3, 4, 5 -  start counting in patch 2 with row 0
-    if ( patch >= 2 ) rowOffset = AliHLTTPCTransform::GetFirstRow( 2 );
-
-    // Initialize block for reading packed data
-    void* tmpdataBlock = (void*) dataBlock;
-    digitReader.InitBlock(tmpdataBlock,dataLen,firstRow,lastRow,patch,slice);
-
-    readValue = digitReader.Next();
-
-    if (!readValue){   
-       LOG(AliHLTTPCLog::kError,"AliHLTTPCDisplayPadRow::Fill","Read first value") << "No value in data block" << ENDLOG;
-       return;
-    }
-
-    // -- Fill Raw Data
-    while ( readValue ){ 
-
-       Int_t row = digitReader.GetRow() + rowOffset;
-
-       // select padrow to fill in histogramm
-       if (row == padRow){    
-           UChar_t tmppad = digitReader.GetPad();
-           UShort_t time = digitReader.GetTime();
-           UInt_t charge = digitReader.GetSignal();
-
-           if (tmppad == (pad-1) ) fHistpad1->Fill(time,charge);
-           if (tmppad == pad) fHistpad2->Fill(time,charge);
-           if (tmppad == (pad+1) ) fHistpad3->Fill(time,charge);
-       }
-       
-       // read next value
-       readValue = digitReader.Next();
-      
-       //Check where to stop:
-       if(!readValue) break; //No more value
-    } 
-#else //! defined(HAVE_TPC_MAPPING)
-      HLTFatal("DigitReaderRaw not available - check your build");
-#endif //defined(HAVE_TPC_MAPPING)
-
+    for (Int_t timeBin=0; timeBin <= fDisplay->GetNTimeBins(); timeBin++){
+      fHistpad2->Fill( timeBin, fDisplay->fRawDataZeroSuppressed[padRow][pad][timeBin] );
+    } // end time
+    
+    for (Int_t timeBin=0; timeBin <= fDisplay->GetNTimeBins(); timeBin++){
+      fHistpad3->Fill( timeBin, fDisplay->fRawDataZeroSuppressed[padRow][nextPad][timeBin] );
+    } // end time
+    
+  }  // end - if ( fDisplay->GetZeroSuppression() ){
+  
+  else {
+    for (Int_t timeBin=0; timeBin <= fDisplay->GetNTimeBins(); timeBin++){
+       fHistpad1->Fill( timeBin, fDisplay->fRawData[padRow][prevPad][timeBin] );
+    } // end time
+    
+    for (Int_t timeBin=0; timeBin <= fDisplay->GetNTimeBins(); timeBin++){
+      fHistpad2->Fill( timeBin, fDisplay->fRawData[padRow][pad][timeBin] );
+      } // end time
+    
+    for (Int_t timeBin=0; timeBin <= fDisplay->GetNTimeBins(); timeBin++){
+      fHistpad3->Fill( timeBin, fDisplay->fRawData[padRow][nextPad][timeBin] );
+    } // end time
+    
+  }  // end - else of if ( fDisplay->GetZeroSuppression() ){
 }
 
 //____________________________________________________________________________________________________
index 974ee9f..4833e2b 100644 (file)
 #include <TH2F.h>
 #include <AliHLTTPCDisplayMain.h>
 #include <AliHLTTPCDisplayPadRow.h>
+#include <AliHLTTPCDisplayFront.h>
 
 class AliHLTTPCDisplayPad : public AliHLTLogging {  
   friend void AliHLTTPCDisplayPadRow::Draw();
+  friend void AliHLTTPCDisplayFront::Draw();
 
  public:
     AliHLTTPCDisplayPad(AliHLTTPCDisplayMain* display) ;
index d30f686..087c1f5 100644 (file)
@@ -140,6 +140,27 @@ void AliHLTTPCDisplayPadRow::Fill(Int_t patch, ULong_t dataBlock, ULong_t dataLe
        return;
     }
 
+    if ( fDisplay->GetZeroSuppression() ){
+      for (Int_t pad=0; pad < AliHLTTPCTransform::GetNPads(padRow); pad++){
+       //      for (Int_t timeBin=fDisplay->GetTimeBinMin(); timeBin <= fDisplay->GetTimeBinMax(); timeBin++){
+       for (Int_t timeBin=0; timeBin <= fDisplay->GetNTimeBins(); timeBin++){
+
+         fHistraw->Fill(pad,timeBin,fDisplay->fRawDataZeroSuppressed[padRow][pad][timeBin]);
+       } // end time
+      }  // end pad
+      
+    }  // end - if ( fDisplay->GetZeroSuppression() ){
+
+    else {
+      for (Int_t pad=0; pad < AliHLTTPCTransform::GetNPads(padRow); pad++){
+       //      for (Int_t timeBin=fDisplay->GetTimeBinMin(); timeBin <= fDisplay->GetTimeBinMax(); timeBin++){
+       for (Int_t timeBin=0; timeBin <= fDisplay->GetNTimeBins(); timeBin++){
+         fHistraw->Fill(pad,timeBin,fDisplay->fRawData[padRow][pad][timeBin]);
+       } // end time
+      }  // end pad
+    }  // end - else of if ( fDisplay->GetZeroSuppression() ){
+
+
     // FILL PADROW 3D --- Initialize the colorbins
     if ( fDisplay->Get3DSwitchPadRow() ){
        for (UInt_t ii=0;ii < 20;ii++){
@@ -191,7 +212,7 @@ void AliHLTTPCDisplayPadRow::Fill(Int_t patch, ULong_t dataBlock, ULong_t dataLe
            UShort_t time = digitReader.GetTime();
            UInt_t charge = digitReader.GetSignal();
            Float_t xyz[3];
-           fHistraw->Fill(pad,time,charge);
+           //fHistraw->Fill(pad,time,charge);
 
            if ( fDisplay->Get3DSwitchPadRow() ) {
                // Transform raw coordinates to local coordinates
@@ -275,7 +296,7 @@ void AliHLTTPCDisplayPadRow::Draw(){
     fHistraw->Draw("COLZ");
     
     if ( fDisplay->ExistsClusterData() ){
-       cout << "XX" <<  endl;
+      //cout << "XX" <<  endl;
        fHistrawcl->SetAxisRange(fBinX[0],fBinX[1]);
        fHistrawcl->SetAxisRange(fBinY[0],fBinY[1],"Y");
        fHistrawcl->SetStats(kFALSE);
index 0593ee2..016d2fd 100644 (file)
@@ -252,8 +252,16 @@ if test "x$with_pubsub" != "xno" ; then
   # currently the different versions of the HLT PubSub framework have a different
   # directory layout
   if test -d ${with_pubsub}/include/HOMER ; then
+    # the 'early' location of the include files with separated HOMER sub dirs
     HOMER_CPPFLAGS="-I${with_pubsub}/include/HOMER -I${with_pubsub}/include/HOMER/reader"
+  elif test -d ${with_pubsub}/include/Util/HOMER ; then
+    # location for HLT Framework versions after Sep 2006
+    HOMER_CPPFLAGS="-I${with_pubsub}/include/Util/HOMER"
+  elif test -d ${with_pubsub}/src/Util/HOMER/include ; then
+    # fall back if include files were not installed (versions after Sep 06)
+    HOMER_CPPFLAGS="-I${with_pubsub}/src/Util/HOMER/include"
   else
+    # fall back if include files were not installed (versions before Sep 06)
     HOMER_CPPFLAGS="-I${with_pubsub}/src/Util/HOMER/reader/include -I${with_pubsub}/src/Util/HOMER/data/include"
   fi
   HOMER_LDFLAGS="-L${with_pubsub}/lib/`uname -s`-`uname -m`"