Latest version of zero suppressed raw data by Ken and Mateusz
authorcblume <cblume@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 20 Aug 2007 11:26:22 +0000 (11:26 +0000)
committercblume <cblume@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 20 Aug 2007 11:26:22 +0000 (11:26 +0000)
21 files changed:
TRD/AliTRDRawStream.cxx
TRD/AliTRDRawStreamV2.cxx [new file with mode: 0644]
TRD/AliTRDRawStreamV2.h [new file with mode: 0644]
TRD/AliTRDReconstructor.cxx
TRD/AliTRDSignalIndex.cxx
TRD/AliTRDSimParam.cxx
TRD/AliTRDSimParam.h
TRD/AliTRDclusterizer.cxx
TRD/AliTRDclusterizerV1.cxx
TRD/AliTRDclusterizerV2.cxx
TRD/AliTRDdigitizer.cxx
TRD/AliTRDdigitizer.h
TRD/AliTRDfeeParam.cxx
TRD/AliTRDfeeParam.h
TRD/AliTRDgeometry.cxx
TRD/AliTRDgeometry.h
TRD/AliTRDmcmSim.cxx
TRD/AliTRDmcmSim.h
TRD/AliTRDrawData.cxx
TRD/TRDbaseLinkDef.h
TRD/libTRDbase.pkg

index d52b600..460508d 100644 (file)
@@ -38,6 +38,7 @@
 #include "AliTRDdataArrayI.h"
 #include "AliTRDSignalIndex.h"
 
+#include "AliTRDfeeParam.h"
 ClassImp(AliTRDRawStream)
 
 //_____________________________________________________________________________
@@ -1041,7 +1042,7 @@ void AliTRDRawStream::DecodeMCMheader()
   fROB  = fMCM / 16;
   fMCM  = fMCM % 16;
 
-  fROW  = fGeo->GetPadRowFromMCM(fROB, fMCM);
+  fROW  = AliTRDfeeParam::Instance()->GetPadRowFromMCM(fROB, fMCM);
 
   AliDebug(4, Form("0x%08x: SM%d L%dS%d. MCM Header: fROB=%d fMCM=%02d fEv=%02d"
                  , *fDataWord, fSM, fLAYER, fSTACK, fROB, fMCM, fEv));
@@ -1231,7 +1232,7 @@ Int_t  AliTRDRawStream::DecodeDataWordV1V2()
   if ( fADC > 1 && fADC < (Int_t)fGeo->ADCmax()-1 ) {
 
     // Get Pad column
-    fCOL = fGeo->GetPadColFromADC(fROB, fMCM, fADC);
+    fCOL = AliTRDfeeParam::Instance()->GetPadColFromADC(fROB, fMCM, fADC);
 
     // We have only 144 Pad Columns
     //if ( fCOL > fColMax-1 || fCOL < 0 ) {
@@ -1322,7 +1323,8 @@ Int_t  AliTRDRawStream::DecodeDataWordV3()
   if ( fADC > 1 && fADC < (Int_t)fGeo->ADCmax()-1 ) {
 
     // Get Pad column
-    fCOL = fGeo->GetPadColFromADC(fROB, fMCM, fADC);
+    //fCOL = fGeo->GetPadColFromADC(fROB, fMCM, fADC);
+    fCOL = AliTRDfeeParam::Instance()->GetPadColFromADC(fROB, fMCM, fADC);
 
     // We have only 144 Pad Columns
     if ( fCOL > fColMax-1 || fCOL < 0 ) {
diff --git a/TRD/AliTRDRawStreamV2.cxx b/TRD/AliTRDRawStreamV2.cxx
new file mode 100644 (file)
index 0000000..b49de6f
--- /dev/null
@@ -0,0 +1,1313 @@
+/**************************************************************************
+ * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ *                                                                        *
+ * Author: The ALICE Off-line Project.                                    *
+ * Contributors are mentioned in the code where appropriate.              *
+ *                                                                        *
+ * Permission to use, copy, modify and distribute this software and its   *
+ * documentation strictly for non-commercial purposes is hereby granted   *
+ * without fee, provided that the above copyright notice appears in all   *
+ * copies and that both the copyright notice and this permission notice   *
+ * appear in the supporting documentation. The authors make no claims     *
+ * about the suitability of this software for any purpose. It is          *
+ * provided "as is" without express or implied warranty.                  *
+ **************************************************************************/
+
+/* $Id$ */
+
+///////////////////////////////////////////////////////////////////////////////
+//                                                                           //
+// This class provides access to TRD digits in raw data.                     //
+//                                                                           //
+// It loops over all TRD digits in the raw data given by the AliRawReader.   //
+// The Next method goes to the next digit. If there are no digits left       //
+// it returns kFALSE.                                                        //
+// Several getters provide information about the current digit.              //
+//                                                                           //
+// Author: C. Lippmann (C.Lippmann@gsi.de)                                   //
+//                                                                           //
+///////////////////////////////////////////////////////////////////////////////
+
+#include "AliLog.h"
+#include "AliRawReader.h"
+#include "AliTRDRawStreamV2.h"
+#include "AliTRDgeometry.h"
+#include "AliTRDcalibDB.h"
+#include "AliTRDfeeParam.h"
+
+#include "AliTRDdigitsManager.h"
+#include "AliTRDdataArrayI.h"
+#include "AliTRDSignalIndex.h"
+
+#include "TMath.h"
+ClassImp(AliTRDRawStreamV2)
+
+//_____________________________________________________________________________
+AliTRDRawStreamV2::AliTRDRawStreamV2() 
+  :TObject()
+  ,fSig()
+  ,fADC(0)
+  ,fTB(0)
+  ,fEv(0)
+  ,fROB(0)
+  ,fMCM(0)
+  ,fSM(0)
+  ,fLAYER(0)
+  ,fSTACK(0)
+  ,fROC(0)
+  ,fSIDE(0)
+  ,fDCS(0)
+  ,fROW(0)
+  ,fCOL(0)
+  ,fDET(0)
+  ,fLastDET(-1)
+  ,fBCctr(0)
+  ,fPTctr(0)
+  ,fPTphase(0)
+  ,fRVmajor(0)
+  ,fRVminor(0)
+  ,fHCHWords(0)
+  ,fTBins(0)
+  ,fTCon(0)
+  ,fPEDon(0)
+  ,fGAINon(0)
+  ,fXTon(0)
+  ,fNonLinOn(0)
+  ,fBypass(0)
+  ,fCommonAdditive(0)
+  ,fZeroSuppressed(0)
+  ,fHCHctr1(0)
+  ,fHCHctr2(0)
+  ,fMCMHctr1(0)
+  ,fMCMHctr2(0)
+  ,fGTUctr1(0)
+  ,fGTUctr2(0)
+  ,fHCdataCtr(0)
+  ,fTracklPID(0.)
+  ,fTracklDefL(0.)
+  ,fTracklPadPos(0.)
+  ,fTracklPadRow(0)
+  ,fGTUlinkMask()
+  ,fMCMWordCrt(0)
+  ,fMCMWordsExpected(0)
+  ,fRawReader(NULL)
+  ,fRawVersion(2)
+  ,fRawDigitThreshold(0)
+  ,fNextStatus(0)
+  ,fLastStatus(0)
+  ,fTbSwitch(0)
+  ,fTbSwitchCtr(0)
+  ,fTimeWords(0)
+  ,fWordCtr(0)
+  ,fRowMax(0)
+  ,fColMax(0)
+  ,fADCmask()
+  ,fLastADCmask(0)
+  ,fChamberDone()
+  ,fRetVal(0)
+  ,fEqID(0)
+  ,fDataSize(0)
+  ,fSizeOK(kFALSE)
+  ,fCountBytes(0)
+  ,fBufSize(0)
+  ,fkBufferSet(kFALSE)
+  ,fPos(NULL)
+  ,fDataWord(NULL)
+  ,fTimeBinsCalib(0)
+  ,fADClookup()
+  ,fNActiveADCs(0)
+  ,fEndOfDataFlag(kFALSE)
+  ,fGeo(NULL) 
+{
+  //
+  // Default constructor
+  //
+
+  for (Int_t i = 0; i < 540; i++) {
+    fChamberDone[i] = 0;
+  }
+
+}
+
+//_____________________________________________________________________________
+AliTRDRawStreamV2::AliTRDRawStreamV2(AliRawReader *rawReader) 
+  :TObject()
+  ,fSig()
+  ,fADC(0)
+  ,fTB(0)
+  ,fEv(0)
+  ,fROB(0)
+  ,fMCM(0)
+  ,fSM(0)
+  ,fLAYER(0)
+  ,fSTACK(0)
+  ,fROC(0)
+  ,fSIDE(0)
+  ,fDCS(0)
+  ,fROW(0)
+  ,fCOL(0)
+  ,fDET(0)
+  ,fLastDET(-1)
+  ,fBCctr(0)
+  ,fPTctr(0)
+  ,fPTphase(0)
+  ,fRVmajor(0)
+  ,fRVminor(0)
+  ,fHCHWords(0)
+  ,fTBins(0)
+  ,fTCon(0)
+  ,fPEDon(0)
+  ,fGAINon(0)
+  ,fXTon(0)
+  ,fNonLinOn(0)
+  ,fBypass(0)
+  ,fCommonAdditive(0)
+  ,fZeroSuppressed(0)
+  ,fHCHctr1(0)
+  ,fHCHctr2(0)
+  ,fMCMHctr1(0)
+  ,fMCMHctr2(0)
+  ,fGTUctr1(0)
+  ,fGTUctr2(0)
+  ,fHCdataCtr(0)
+  ,fTracklPID(0.)
+  ,fTracklDefL(0.)
+  ,fTracklPadPos(0.)
+  ,fTracklPadRow(0)
+  ,fGTUlinkMask()
+  ,fMCMWordCrt(0)
+  ,fMCMWordsExpected(0)
+  ,fRawReader(rawReader)
+  ,fRawVersion(2)
+  ,fRawDigitThreshold(0)
+  ,fNextStatus(0)
+  ,fLastStatus(0)
+  ,fTbSwitch(0)
+  ,fTbSwitchCtr(0)
+  ,fTimeWords(0)
+  ,fWordCtr(0)
+  ,fRowMax(0)
+  ,fColMax(0)
+  ,fADCmask()
+  ,fLastADCmask(0)
+  ,fChamberDone()
+  ,fRetVal(0)
+  ,fEqID(0)
+  ,fDataSize(0)
+  ,fSizeOK(kFALSE)
+  ,fCountBytes(0)
+  ,fBufSize(0)
+  ,fkBufferSet(kFALSE)
+  ,fPos(NULL)
+  ,fDataWord(NULL)
+  ,fTimeBinsCalib(0)
+  ,fADClookup()
+  ,fNActiveADCs(0)
+  ,fEndOfDataFlag(kFALSE)
+  ,fGeo(NULL) 
+{
+  //
+  // Create an object to read TRD raw digits
+  //
+
+  fRawReader->Select("TRD");
+
+  for (Int_t i = 0; i < 540; i++) {
+    fChamberDone[i] = 0;
+  }
+
+}
+
+//_____________________________________________________________________________
+AliTRDRawStreamV2::AliTRDRawStreamV2(const AliTRDRawStreamV2& stream)
+  :TObject(stream)
+  ,fSig()
+  ,fADC(-1)
+  ,fTB(-1)
+  ,fEv(-1)
+  ,fROB(-1)
+  ,fMCM(-1)
+  ,fSM(-1)
+  ,fLAYER(-1)
+  ,fSTACK(-1)
+  ,fROC(-1)
+  ,fSIDE(-1)
+  ,fDCS(-1)
+  ,fROW(-1)
+  ,fCOL(-1)
+  ,fDET(0)
+  ,fLastDET(-1)
+  ,fBCctr(-1)
+  ,fPTctr(-1)
+  ,fPTphase(-1)
+  ,fRVmajor(-1)
+  ,fRVminor(-1)
+  ,fHCHWords(-1)
+  ,fTBins(-1)
+  ,fTCon(0)
+  ,fPEDon(0)
+  ,fGAINon(0)
+  ,fXTon(0)
+  ,fNonLinOn(-1)
+  ,fBypass(-1)
+  ,fCommonAdditive(-1)
+  ,fZeroSuppressed(0)
+  ,fHCHctr1(-1)
+  ,fHCHctr2(-1)
+  ,fMCMHctr1(-1)
+  ,fMCMHctr2(-1)
+  ,fGTUctr1(-1)
+  ,fGTUctr2(-1)
+  ,fHCdataCtr(-1)
+  ,fTracklPID(-1.)
+  ,fTracklDefL(-1.)
+  ,fTracklPadPos(-1.)
+  ,fTracklPadRow(-1)
+  ,fGTUlinkMask()
+  ,fMCMWordCrt(0)
+  ,fMCMWordsExpected(0)
+  ,fRawReader(NULL)
+  ,fRawVersion(-1)
+  ,fRawDigitThreshold(0)
+  ,fNextStatus(0)
+  ,fLastStatus(0)
+  ,fTbSwitch(0)
+  ,fTbSwitchCtr(0)
+  ,fTimeWords(0)
+  ,fWordCtr(0)
+  ,fRowMax(-1)
+  ,fColMax(-1)
+  ,fADCmask()
+  ,fLastADCmask(0)
+  ,fChamberDone()
+  ,fRetVal(0)
+  ,fEqID(0)
+  ,fDataSize(0)
+  ,fSizeOK(kFALSE)
+  ,fCountBytes(0)
+  ,fBufSize(0)
+  ,fkBufferSet(kFALSE)
+  ,fPos(NULL)
+  ,fDataWord(NULL)
+  ,fTimeBinsCalib(0)
+  ,fADClookup()
+  ,fNActiveADCs(0)
+  ,fEndOfDataFlag(kFALSE)
+  ,fGeo(NULL)
+{
+  //
+  // Copy constructor
+  //
+
+  AliFatal("Copy constructor not implemented");
+
+}
+
+//_____________________________________________________________________________
+AliTRDRawStreamV2& AliTRDRawStreamV2::operator = (const AliTRDRawStreamV2& 
+                                             /* stream */)
+{
+  //
+  // Assigment operator
+  //
+
+  Fatal("operator =", "assignment operator not implemented");
+  return *this;
+
+}
+
+//_____________________________________________________________________________
+AliTRDRawStreamV2::~AliTRDRawStreamV2()
+{
+  //
+  // Destructor
+  //
+
+  if (fGeo) {  
+    delete fGeo;
+  }
+
+}
+
+//_____________________________________________________________________________
+void AliTRDRawStreamV2::SetRawReader(AliRawReader *rawReader) 
+{
+  //
+  // Set the rawreader
+  //
+
+  if (rawReader)
+    {
+      fRawReader = rawReader;
+    }
+}
+
+//_____________________________________________________________________________
+Bool_t AliTRDRawStreamV2::SetRawVersion(Int_t rv)
+{
+  //
+  // Set the raw data version
+  //
+
+  if ( rv >= 0 && rv <= 3 ) {
+    fRawVersion = rv;
+    return kTRUE;
+  }
+
+  return kFALSE;
+
+}
+
+
+//____________________________________________________________________________
+Int_t AliTRDRawStreamV2::Init()
+{
+  //
+  // Initialization
+  //
+
+  if (!AliTRDcalibDB::Instance()) {
+    AliError("Could not get calibration object");
+    return 0;
+  }
+
+  if (!fGeo) {
+    fGeo = new AliTRDgeometry();
+  }
+  
+  fTimeBinsCalib = AliTRDcalibDB::Instance()->GetNumberOfTimeBins();
+  //AliDebug(2, Form("Number of Timebins read from CDB: %d", fTimeBinsCalib));
+
+  // The number of data words needed for this number of time bins (there
+  // are 3 time bins in one word)
+  fTimeWords = (fTimeBinsCalib-1)/3 + 1;
+
+  fTbSwitch    = 3;
+  fTbSwitchCtr = 0;
+
+  fHCHctr1 = fHCHctr2 =  0;
+  fGTUctr1 = fGTUctr2 = -1;
+
+  fHCdataCtr = 0;
+  fWordCtr   = 0;  
+
+  fDET     = 0;
+  fLastDET     = -1;
+  fRetVal = 0;
+  fEqID     = 0;
+  fDataSize = 0;
+  fSizeOK = kFALSE;
+  
+  fLastStatus = fkStart;
+  fNextStatus = fkStart;
+
+  fCountBytes = 0;
+  fBufSize = 0;
+  fDataWord = NULL;
+  fPos = NULL;
+  fWordCtr = 0;
+  fkBufferSet = kFALSE;
+
+  fMCMWordCrt = 0;
+  fMCMWordsExpected = 0;
+
+  fEndOfDataFlag = kFALSE;
+  // set all ADC active
+  fNActiveADCs = ChannelsToRead(0x1fffff); // should be 1111 1111 1111 1111 1111 1 = 21 bits active (0-20)
+
+  fLastADCmask = 0;
+
+  return kTRUE;
+}
+
+//____________________________________________________________________________
+Int_t AliTRDRawStreamV2::NextData()
+{
+  //
+  // Updates the next data word pointer
+  //
+
+  if (fCountBytes + kSizeWord >= fBufSize)
+    {
+      fkBufferSet = fRawReader->ReadNextData(fPos);
+      if (fkBufferSet == kTRUE)
+       {
+         fBufSize = fRawReader->GetDataSize();
+         fCountBytes = 0;        
+         fDataWord = (UInt_t*)fPos;
+         ChangeStatus(fkNextSM);
+         fWordCtr = 0;
+         return fkNextSM;
+       }
+      else
+       {
+         ChangeStatus(fkStop);
+         return fkNoMoreData;
+       }
+    }
+  else
+    {
+      fPos += kSizeWord;
+      fCountBytes += kSizeWord;          
+      fDataWord = (UInt_t*)fPos;
+      fWordCtr++;
+      return fkWordOK;
+    }
+}
+
+//============================================================================
+// Decoding functions
+//============================================================================
+
+
+//____________________________________________________________________________
+void AliTRDRawStreamV2::DecodeHCheader(Int_t timeBins)
+{
+  //
+  // Decode the HC header (fRawVersion == 2, 3, 4, ???)
+  //
+
+  fRVmajor = (*fDataWord >> 24) & 0x7f;
+  fRVminor = (*fDataWord >> 17) & 0x7f;
+
+  if (fRVmajor < 2 || fRVmajor > 4)
+    AliError(Form(" Unsupported raw version: %d", fRawVersion))
+  
+  if ( fRawVersion != fRVmajor ) {
+    
+    AliWarning("===============================================================================");
+    AliWarning(Form("Mismatch between fRawVersion (%d) and fRVmajor from HC header (%d)"
+                   ,fRawVersion,fRVmajor));
+    AliWarning(Form("Setting fRawVersion to %d", fRVmajor));
+    AliWarning("===============================================================================");
+    fRawVersion = fRVmajor;
+
+  }
+
+  //
+  // check for zero suppression
+  if ( fRawVersion >= 3 || fRawVersion <= 4 ) fZeroSuppressed = kTRUE;
+  else                                        fZeroSuppressed = kFALSE;
+  
+  // 1st word (h[0])
+  if ( (*fDataWord & 0x3) == 1 ) {
+
+    fHCHWords = (*fDataWord >> 14) & 0x7;
+    fSM       = (*fDataWord >>  9) & 0x1f;
+    fLAYER    = (*fDataWord >>  6) & 0x7;
+    fSTACK    = (*fDataWord >>  3) & 0x7;
+    fSIDE     = (*fDataWord >>  2) & 0x1;
+
+    fROC      = fGeo->GetDetectorSec(fLAYER, fSTACK);
+
+    //AliDebug(3, Form("0x%08x: HC header: sm=%d; roc=%d; side=%x", *fDataWord, fSM, fROC, fSIDE+10));
+    //AliDebug(5, Form("0x%08x: HC header: expecting %d HC words", *fDataWord, fHCHWords));
+
+    if ((fSM    <  0) || 
+        (fSM    > 17) || 
+        (fLAYER <  0) || 
+        (fLAYER >  5) || 
+        (fSTACK <  0) || 
+        (fSTACK >  4) || 
+        (fSIDE  <  0) || 
+        (fSIDE  >  1)) 
+      {
+       AliWarning(Form("0x%08x: Strange HC header: dcs=%d; sm=%d; layer=%d; stack=%d.",
+                       *fDataWord, fDCS, fSM, fLAYER, fSTACK));
+       fRawReader->AddMajorErrorLog(kHCHeaderCorrupt,Form("0x%08x:dcs=%d; sm=%d; layer=%d; stack=%d.",
+                                                          *fDataWord, fDCS, fSM, fLAYER, fSTACK));
+      } 
+    else 
+      {
+       fHCHctr1++;
+       fHCHctr2++;
+      }
+  } 
+  else 
+    { 
+      AliWarning(Form("0x%08x: No HC header when it was expected.", *fDataWord)); 
+      fRawReader->AddMajorErrorLog(kHCHeaderMissing,Form("0x%08x", *fDataWord));
+    }
+
+  // 2nd word (h[1])
+  if ( fHCHWords >= 1 ) 
+    {
+      // read one more word
+      if (NextData() != fkWordOK)
+       {
+         AliWarning("Next HC word missing");
+         fRawReader->AddMajorErrorLog(kHCWordMissing,"Next HC word missing"); 
+         fNextStatus = fkNextHC;
+         return;
+       }
+
+      if ( (*fDataWord & 0x3) == 1 ) 
+       {
+         
+         fBCctr   =  (*fDataWord >> 16);
+         fPTctr   =  (*fDataWord >> 12) & 0xf;
+         fPTphase =  (*fDataWord >>  8) & 0xf;
+         fTBins   = ((*fDataWord >>  2) & 0x3f) + 1;
+         fTimeWords = (fTBins - 1)/3 + 1;      
+         
+//       AliDebug(3, Form("0x%08x: HC header 2: BCctr=%d PTctr=%d PTph=%d TB=%d"
+//                        , *fDataWord, fBCctr, fPTctr, fPTphase, fTBins));
+
+         if( fTBins != timeBins ) 
+           {         
+             AliWarning("===============================================================================");
+             AliError(Form("Mismatch between nNTB from CDB (%d) and from HC header (%d)"
+                           , timeBins, fTBins));
+             AliWarning(Form("We will use the value from the raw data (HC header): %d", fTBins));
+             AliWarning("===============================================================================");          
+
+             fTimeWords = (fTBins - 1)/3 + 1;  
+           }
+       }      
+    }
+
+  // 3nd word (h[2])
+  if ( fHCHWords >= 2 ) {
+    // read one more word
+    if (NextData() != fkWordOK)
+      {
+       AliWarning("Next HC word missing");
+        fRawReader->AddMajorErrorLog(kHCWordMissing,"Next HC word missing"); 
+       fNextStatus = fkNextHC;
+       return;
+      }
+    if ( (*fDataWord & 0x3) == 1 ) {
+       
+      fTCon     = (*fDataWord >> 29) & 0x1;
+      fPEDon    = (*fDataWord >> 31) & 0x1;
+      fGAINon   = (*fDataWord >> 30) & 0x1;
+      fXTon     = (*fDataWord >> 28) & 0x1;
+      fNonLinOn = (*fDataWord >> 27) & 0x1;
+      fBypass   = (*fDataWord >> 26) & 0x1;
+
+      fCommonAdditive = (*fDataWord >> 20) & 0x3f;
+
+//       AliDebug(3, Form("0x%08x: HC header 3: TC=%d, PED=%d, GAIN=%d, XT=%d, NonLin=%d, Bypass=%d, Add=%d"
+//                   , fTCon, fPEDon, fGAINon, fXTon, fNonLinOn, fBypass, fCommonAdditive));
+    }
+  }
+
+}  
+
+//____________________________________________________________________________
+Int_t AliTRDRawStreamV2::ChannelsToRead(Int_t ADCmask)
+{
+  memset(fADClookup, -1, 32 * sizeof(Int_t));
+  fADClookup[0] = 0; // count entries
+  fADClookup[1] = 2; // index - data start at 2
+  UInt_t mask = 0;
+  for (Int_t i = 0; i < 30; i++)
+    {
+      mask = 1 << i;
+      if ((ADCmask & mask))
+       {
+         //AliDebug(9, Form("fDataWord=0x%08x mask=0x%08x i=%d", *fDataWord, mask, i));
+         fADClookup[fADClookup[1]] = i;
+         ++fADClookup[0];
+         ++fADClookup[1];
+       }
+    }
+
+  // test the iteration - comment out for production
+  // begin of comment out section
+  char schannels[512];
+  sprintf(schannels, "ADC Channels to read: ");
+  fADClookup[1] = 2;
+  while(fADClookup[1] - 2 < fADClookup[0])
+    {
+      //AliDebug(9, Form("max=%d index=%d adc=%d", fADClookup[0], fADClookup[1], fADClookup[fADClookup[1]]));
+      strcat(schannels, Form("%d ", fADClookup[fADClookup[1]]));
+      fADClookup[1]++;
+    }
+  //AliDebug(9, Form("%s", schannels));
+  //AliDebug(9, Form("ADC channels = %d", fADClookup[0]));
+  // end of comment out section
+
+  fADClookup[1] = 2;
+  return fADClookup[0];
+}
+
+//____________________________________________________________________________
+void AliTRDRawStreamV2::DecodeTracklet()
+{
+
+  //
+  // Decode the Tracklet
+  //
+  // this function is not tested yet on real tracklets
+  //
+
+  if ( fRawVersion < 1 || fRawVersion > 3 ) 
+    {
+      AliError(Form(" Unsupported raw version: %d", fRawVersion));      
+    }
+
+  fTracklPID    = (*fDataWord >> 24) & 0xff;
+  fTracklPadRow = (*fDataWord >> 20) & 0xf;    // 0:15
+  fTracklDefL   = (*fDataWord >> 13) & 0x7f;
+  fTracklPadPos = (*fDataWord)       & 0x1fff;
+
+  fTracklPID    /= (Float_t)((1<<8) - 1);                      // 0:1 (steps of 0.39%)
+  fTracklDefL    = (fTracklDefL  - ((1<< 7)-1)/2.) * 140.e-4;  // -0.889:0.889cm 
+  fTracklPadPos  = (fTracklPadPos - ((1<<13)-1)/2.) * 160.e-4; // -65.528:65.528 cm
+
+  //AliDebug(4, Form("0x%08x: Tracklet found: SM%d L%dS%d side %x: PadRow=%d PadPos=%f DefL=%f PID=%f"
+  //             , *fDataWord, fSM, fLAYER, fSTACK, fSIDE+10
+  //                , fTracklPadRow, fTracklPadPos, fTracklDefL, fTracklPID));
+
+  if( (fSTACK == 2) && (fTracklPadRow >= (Int_t) fGeo->RowmaxC0()) ||
+      (fSTACK != 2) && (fTracklPadRow >= (Int_t) fGeo->RowmaxC1()) ) {
+    AliWarning(Form("Strange Row read from Tracklet Word: %d", fTracklPadRow));
+    fRawReader->AddMajorErrorLog(kTrackletRowMismatch,Form("Word: %d", fTracklPadRow));
+  }
+
+}
+
+//____________________________________________________________________________
+void AliTRDRawStreamV2::DecodeMCMheader()
+{
+
+  //
+  // Decode the MCM header
+  //
+
+  if ( fRawVersion < 1 || fRawVersion > 3 ) 
+    {
+      AliError(Form(" Unsupported raw version: %d", fRawVersion));      
+    }
+
+  fMCM  = (*fDataWord & 0xff000000) >> 24;
+  fEv   = (*fDataWord & 0x00fffff0) >> 4;
+
+  fROB  = fMCM / 16;
+  fMCM  = fMCM % 16;
+
+  fROW  = AliTRDfeeParam::Instance()->GetPadRowFromMCM(fROB, fMCM);
+
+//   AliDebug(4, Form("0x%08x: SM%d L%dS%d. MCM Header: fROB=%d fMCM=%02d fEv=%02d"
+//               , *fDataWord, fSM, fLAYER, fSTACK, fROB, fMCM, fEv));
+
+  if ( fROB % 2 == 0 && fSIDE == 1 ) {
+    AliWarning(Form("SM%d L%dS%d: Mismatch between fROB (%d) and fSIDE (%d): fMCM=%02d"
+                   , fSM, fLAYER, fSTACK, fROB, fSIDE, fMCM ));
+    fRawReader->AddMajorErrorLog(kROBSideMismatch,Form("SM%d L%dS%d: fROB (%d) fSIDE (%d): fMCM=%02d"
+                                                      , fSM, fLAYER, fSTACK, fROB, fSIDE, fMCM ));
+  }
+  if ( fROB % 2 != 0 && fSIDE == 0 ) {
+    AliWarning(Form("SM%d L%dS%d: Mismatch between fROB (%d) and fSIDE (%d): fMCM=%02d"
+                   , fSM, fLAYER, fSTACK, fROB, fSIDE, fMCM ));
+    fRawReader->AddMajorErrorLog(kROBSideMismatch,Form("SM%d L%dS%d: fROB (%d) fSIDE (%d): fMCM=%02d"
+                                                      , fSM, fLAYER, fSTACK, fROB, fSIDE, fMCM ));
+  }
+  if ( (fSTACK == 2 && fROW >= fGeo->RowmaxC0()) ||
+       (fSTACK != 2 && fROW >= fGeo->RowmaxC1()) || fROW < 0 ) {
+    AliWarning(Form("SM%d L%dS%d: Wrong Padrow (%d) fROB=%d, fSIDE=%d, fMCM=%02d"
+                   , fSM, fLAYER, fSTACK, fROW, fROB, fSIDE, fMCM ));
+    fRawReader->AddMajorErrorLog(kWrongPadrow,Form("SM%d L%dS%d: Padrow (%d) fROB=%d, fSIDE=%d, fMCM=%02d"
+                                                 , fSM, fLAYER, fSTACK, fROW, fROB, fSIDE, fMCM ));
+  }
+  
+  fMCMHctr1++;
+  fMCMHctr2++;
+
+  fMCMWordCrt = 1; // MCM header
+
+  // AdcMask for Zero supressed data
+  if ( fRawVersion == 3 ) 
+    {
+      // read one more word
+      if (NextData() != fkWordOK)
+       {
+         AliWarning("MCM ADC mask missing");
+         fRawReader->AddMajorErrorLog(kMCMADCMaskMissing,"Missing"); 
+         fNextStatus = fkNextHC;
+         return;
+       }
+      else
+       {
+         ++fMCMWordCrt;
+
+         for ( Int_t ctr = 0; ctr < fGeo->ADCmax(); ctr++ ) {
+           if ( (*fDataWord >> (11+ctr)) == 0x1 ) fADCmask[ctr] = kTRUE;
+           else                                  fADCmask[ctr] = kFALSE;
+         }
+         
+         //AliDebug(4, Form("0x%08x: ADC mask", *fDataWord));
+         fNActiveADCs = ChannelsToRead(*fDataWord);      
+       }
+    }
+
+  if (fRawVersion <= 2)
+    {
+      // no zero suppression
+      // raw version 2:
+      // 1 MCM header + 21 * ( Ntimebin/3)
+      // If NTimebin = 30, it is 211 words. 
+      //fMCMWordsExpected = 1 + 21 * (fTBins / 3);
+      //fNActiveADCs = 21;
+      fNActiveADCs = ChannelsToRead(0x1fffff); // should be 1111 1111 1111 1111 1111 1 = 21 bits active (0-20)
+      //fMCMWordsExpected = 1 + fNActiveADCs * ((fTBins-1) / 3. + 1.);      
+      //directly get it like that:
+      fMCMWordsExpected = 1 + fNActiveADCs * fTBins / 3;      
+    }
+
+  if (fRawVersion >= 3)
+    {
+      // raw version 3:
+      // 1 MCM header + 1 ADC mask + NofActiveADCs * ( Ntimebin/3 )
+      //directly get it like that:
+      fMCMWordsExpected = 1 + 1 + (fTBins * fNActiveADCs) / 3;
+    }
+  
+  //AliDebug(5, Form("We expect %d MCM words. We read %d so far.", fMCMWordsExpected, fMCMWordCrt));
+}
+//____________________________________________________________________________
+Bool_t AliTRDRawStreamV2::DecodeNextRawWord()
+{
+  //AliDebug(8, Form("-----------------------------------------"));
+  //AliDebug(8, Form("DATA IS 0x%x", *fDataWord));
+
+  if (fADClookup[1] - 2 > fADClookup[0])
+    {
+//       AliDebug(8, Form("Overflow Index ADC = %d Max Index = %d Value = %d. Done with ADCs in this MCM. Is this already MCM header 0x%x?", 
+//                    fADClookup[1] - 2, fADClookup[0], fADClookup[fADClookup[1]], *fDataWord));
+      fTbSwitchCtr = 0;
+      fMCMWordsExpected = 0;
+      AliWarning("Trying to recover. Fall back to DecodeMCM.");
+      DecodeMCM();
+      //ChangeStatus(fkNextMCM);
+      return kFALSE;
+    }
+
+  if ( (*fDataWord & 0x00000003) != 0x2 && (*fDataWord & 0x00000003) != 0x3) {
+    AliWarning(Form("Data %08x : Data Word ends neither with b11 nor b10", (Int_t)*fDataWord));
+    fRawReader->AddMinorErrorLog(kDataMaskError,Form("Data %08x", (Int_t)*fDataWord));
+    fMCMWordsExpected = 0;
+    AliWarning("Trying to recover. Fall back to DecodeMCM.");
+    DecodeMCM();
+    //ChangeStatus(fkNextMCM);
+    return kFALSE;
+  }
+
+  if ( (*fDataWord & 0x3) != fLastADCmask) 
+    {    
+      fADC = fADClookup[fADClookup[1]];
+//       AliDebug(8, Form("Next fADC = %d at index = %d MCM Word Number: %d Max MCM Words is %d", 
+//                    fADC, fADClookup[1] - 2, fMCMWordCrt, fMCMWordsExpected));
+      ++fADClookup[1];
+      fTB = 0;    
+      fLastStatus = fkNextData;
+      fLastADCmask = (*fDataWord) & 0x3;
+    }
+
+  //decode data here
+  Bool_t kIsDataOK = kFALSE;
+
+  // We have only 21 ADC channels.
+  if ( fADC > (Int_t)fGeo->ADCmax() - 1 ) 
+    {
+      AliWarning(Form("Data %08x : Data is strange. fADC is already %d", (Int_t)*fDataWord, (Int_t)fADC));
+      fRawReader->AddMinorErrorLog(kADCChannelOverflow,Form("Data %08x : fADC=%d", (Int_t)*fDataWord, (Int_t)fADC));
+    }
+  else
+    {
+      // There are 18 pads connected to each MCM ADC channels 2...19. The other channels cross to other
+      // MCMs and are good for online tracking in the MCM.
+      if ( fADC > 1 && fADC < (Int_t)fGeo->ADCmax() - 1 ) 
+       {
+         
+         // Get Pad column
+         // fCOL = fFee->GetPadColFromADC(fROB, fMCM, fADC);
+         fCOL = AliTRDfeeParam::Instance()->GetPadColFromADC(fROB, fMCM, fADC);
+         
+         // We have only 144 Pad Columns
+         //if ( fCOL > fColMax-1 || fCOL < 0 ) 
+         if ( fCOL >= 0 && fCOL < fColMax && fROW >= 0 && fROW < fRowMax ) 
+           {
+             // Decode 32 bit data words with information from 3 time bins and copy the data
+             fSig[0] = (*fDataWord & 0x00000ffc) >> 2;
+             fSig[1] = (*fDataWord & 0x003ff000) >> 12;
+             fSig[2] = (*fDataWord & 0xffc00000) >> 22;
+             
+             // Print data to screen:
+             //AliDebug(5, Form("DATA : 0x%x", *fDataWord));
+             //          AliDebug(5, Form("SM%d L%dS%d: ROB%d MCM=%d ADC=%d (ROW=%d COL=%d): Data %04d %04d %04d\n",
+             //                           fSM, fLAYER, fSTACK, fROB, fMCM, fADC, fROW, fCOL, fSig[0], fSig[1], fSig[2]));            
+             kIsDataOK = kTRUE;
+           }
+         else
+           {
+             AliWarning(Form("SM%d L%dS%d: Wrong Pad column (%d) fROB=%d, fSIDE=%d, fMCM=%02d", fSM,
+                             fLAYER, fSTACK, fCOL, fROB, fSIDE, fMCM ));
+             fRawReader->AddMajorErrorLog(kWrongPadcolumn,Form("SM%d L%dS%d: column (%d) fROB=%d, fSIDE=%d, fMCM=%02d", fSM,
+                                                               fLAYER, fSTACK, fCOL, fROB, fSIDE, fMCM ));
+             kIsDataOK = kFALSE;
+           }
+       }
+      else 
+       {      
+         //AliDebug(5, Form("fADC not accepted %d - DATA : 0x%x", fADC, *fDataWord));
+         fCOL = -1;
+         kIsDataOK = kFALSE;
+       }
+    }// if fADC is ok
+
+  ++fMCMWordCrt;
+  //AliDebug(5, Form("We expect %d MCM words. We read %d so far.", fMCMWordsExpected, fMCMWordCrt));
+
+  // all mcm data processed go to next one
+  if ( fMCMWordCrt >= fMCMWordsExpected)
+    {
+      ChangeStatus(fkNextMCM);
+    }
+
+  return kIsDataOK;
+}
+
+//____________________________________________________________________________
+Bool_t AliTRDRawStreamV2::DecodeMCM()
+{
+  if( ((*fDataWord & 0x80000000) == 0x0) && ((*fDataWord & 0x0000000f) == 0xC) )
+    { // MCM Header
+      DecodeMCMheader();
+      if ( fMCM < 0 || fMCM > 15 || fROB < 0 || fROB > 7 ) 
+       {
+         AliWarning("Wrong fMCM or fROB. Skip this data");
+         fRawReader->AddMajorErrorLog(kWrongMCMorROB,Form("MCM=%d, ROB=%d",fMCM,fROB));
+         ChangeStatus(fkNextHC);
+         return kFALSE;
+       }
+
+      fTbSwitch    = 3;  // For first adc channel we expect: (*fDataWord & 3) = 3
+      fTbSwitchCtr = 0;  // 
+      fADC = fTB   = 0;  // Reset Counter
+      fLastADCmask = 0; // Reset
+
+      if (fMCMWordCrt < fMCMWordsExpected)
+       {
+         ChangeStatus(fkNextData);
+       }
+      else
+       {
+         ChangeStatus(fkNextMCM);
+       }
+      return kTRUE;
+    }
+
+  if ( *fDataWord == kEndofrawdatamarker ) 
+    {  // End of half-chamber data, finished
+      fGTUctr1 = -1;
+      ChangeStatus(fkNextHC);
+      fEndOfDataFlag = kTRUE;
+      //AliDebug(5, "Expecting MCM header but got End-Of-Raw-Data Marker");
+      if (fMCMWordsExpected == 0 || fMCMWordsExpected == fMCMWordCrt)
+       return kTRUE;
+      else
+       {
+         //AliDebug(5, Form("MCM words missing? %d [expected=%d got=%d] ", fMCMWordsExpected - fMCMWordCrt, fMCMWordsExpected, fMCMWordCrt));    
+         //AliWarning(Form("MCM words missing? %d [expected=%d got=%d] ", fMCMWordsExpected - fMCMWordCrt, fMCMWordsExpected, fMCMWordCrt));     
+         return kFALSE;
+       }
+    }
+
+  //AliDebug(3, Form("Expecting MCM header but got 0x%x. Going to Next MCM header.", *fDataWord));
+  AliWarning(Form("Expecting MCM header but got 0x%x. Fall back: Next MCM header.", *fDataWord));
+  ChangeStatus(fkNextMCM);      
+
+  return kFALSE;
+}
+
+//____________________________________________________________________________
+Bool_t AliTRDRawStreamV2::DecodeHC()
+{
+  if ( fNextStatus == fkNextHC )
+    {
+      //AliDebug(5, "fkNextHC");
+      //
+      // 1) Find end_of_tracklet_marker
+      //
+      // GTU Link Mask?
+      if (DecodeGTUlinkMask())
+       {
+         return kTRUE;
+       }
+      
+      // endoftrackletmarker?
+      if ( *fDataWord == kEndoftrackletmarker ) 
+       {
+         //AliDebug(3, "End-of-tracklet-marker found");
+         //AliDebug(5, Form("Data 0x%x", *fDataWord));
+         ChangeStatus(fkSeekNonEoTracklet);
+         return kTRUE;
+       } 
+      else 
+       {
+         // Tracklets found
+         //AliDebug(3, "Tracklet found");
+         //AliDebug(5, Form("Tracklet data 0x%x", *fDataWord));
+         DecodeTracklet();
+         return kTRUE;
+       }
+    } // if next HC
+
+  if (fNextStatus == fkSeekNonEoTracklet)
+    {
+      //AliDebug(5, "fkSeekNonEoTracklet");
+
+      //
+      // 2) Look for non-end_of_tracklet_marker
+      //
+      //printf("Word %d: 0x%08x\n", fWordCtr, *fDataWord); 
+      
+      if ( *fDataWord != kEndoftrackletmarker ) 
+       {
+         ChangeStatus(fkDecodeHC);
+         //AliDebug(3, "NON end-of-tracklet-marker found");
+         //AliDebug(5, Form("Data 0x%x", *fDataWord));
+         //// no do not continue - this should be the hcheader
+       }
+      else
+       {
+         //just go on and find the non-end_of_tracklet_marker
+         return kTRUE;
+       }
+    }
+
+  if ( fNextStatus == fkDecodeHC )
+    {
+      //AliDebug(5, "fkDecodeHC");
+      
+      //
+      // 3) This Word must be Half Chamber Header
+      //
+      if ( (*fDataWord & 0x00000003) == 1 ) 
+       { // HC header
+         DecodeHCheader(fTimeBinsCalib); // This is the new header!
+         fLastDET = fDET;
+         fDET    = fGeo->GetDetector(fLAYER, fSTACK, fSM);
+         fRowMax = fGeo->GetRowMax(fLAYER,fSTACK,fSM);
+         fColMax = fGeo->GetColMax(fROC);
+         
+         fMCMHctr2 = 0;
+         fHCdataCtr = 0;
+         fChamberDone[fDET]++;
+         //AliDebug(6, Form("--------------      DET %d fChamberDone[fDET]=%d", fDET, fChamberDone[fDET]));
+
+         ChangeStatus(fkNextMCM);
+         return kTRUE;
+       } //HC header
+      else
+       {
+         AliWarning(Form("Expecting HC header mask but got 0x%x. Fall back: Next HC.", *fDataWord));
+         ChangeStatus(fkNextHC);
+         // before we went to //ChangeStatus(fkNextSM);
+       }
+    } // if decode HC
+  
+  return kFALSE;
+}
+//____________________________________________________________________________
+Bool_t AliTRDRawStreamV2::DecodeGTUlinkMask()
+{
+  //
+  // Decode the link masks sent by the GTU. These marke the active optical links
+  // between GTU and Super Module. Up to now only fully active links are found
+  // (0xfff = 12 active links).
+  //
+
+  if ( (*fDataWord & 0xfffff000) ==  0xe0000000 )
+    {
+      if ( fRawVersion < 1 || fRawVersion > 3 ) 
+       {
+         AliError(Form(" Unsupported raw version: %d", fRawVersion));      
+       }
+      
+      if ( fGTUctr1 == -1 ) fGTUctr2++;
+      fGTUctr1++;
+
+      if ( (fGTUctr1 >= 0) && (fGTUctr1 < 5) && (fGTUctr2 >= 0) && (fGTUctr2 < 18) ) 
+       {
+         fGTUlinkMask[fGTUctr2][fGTUctr1] = (*fDataWord & 0xfff);
+       }
+     
+      //AliDebug(5, Form("GTU link mask 0x%x decoded 0x%x", *fDataWord, fGTUlinkMask[fGTUctr2][fGTUctr1]));
+      return kTRUE;
+    }
+
+  return kFALSE;
+}
+
+// //____________________________________________________________________________
+void AliTRDRawStreamV2::ChangeStatus(Int_t kstat)
+{
+  fLastStatus = fNextStatus;
+  fNextStatus = kstat;  
+}
+
+//____________________________________________________________________________
+Bool_t AliTRDRawStreamV2::DecodeSM()
+{
+  fDET     = 0;
+  fRetVal = 0;
+  fEqID     = 0;
+  fDataSize = 0;
+  fSizeOK = kFALSE;
+  
+  // After reading the first word check for size of this data and get Eq. ID
+  if ( fWordCtr == 1 ) 
+    {
+      fDataSize = fRawReader->GetDataSize()/4;  // Size of this payload in 32bit words
+      fEqID     = fRawReader->GetEquipmentId(); // Get Equipment ID
+      if ( fDataSize > 0 ) fSizeOK = kTRUE;
+      //AliDebug(3, Form("fDataSize=%d fEqID=%d", fDataSize, fEqID));
+    }
+  
+  // GTU Link Mask?
+  if ( DecodeGTUlinkMask() ) 
+    {
+      ChangeStatus(fkNextHC);
+      return kTRUE;
+    } 
+  else 
+    {
+      AliWarning(Form("Equipment %d: First data word is not GTU Link Mask! Fall back: None. Stop.", fEqID));
+      fRawReader->AddMajorErrorLog(kGTULinkMaskMissing,Form("Equipment %d",fEqID));
+      ChangeStatus(fkStop);
+    }      
+
+  return kFALSE;
+}
+
+//____________________________________________________________________________
+Bool_t AliTRDRawStreamV2::Next()
+{
+  //
+  // Updates the next data word pointer
+  //
+
+  if (fNextStatus == fkStart)
+    {
+      Init();
+    }
+
+  while (fNextStatus != fkStop)
+    { // !fkStop
+      NextData();
+      
+      switch (fNextStatus)
+       {
+       case fkNextData:
+         {
+         if (DecodeNextRawWord() == kTRUE)
+           {
+             fTB += 3;
+             if (fSig[0] > fRawDigitThreshold || fSig[1] > fRawDigitThreshold || fSig[2] > fRawDigitThreshold) 
+               return kTRUE;
+           }
+         }; break;
+       case fkNextMCM:
+         {
+           if (DecodeMCM() == kFALSE)
+             AliWarning(Form("Decode MCM unsuccessfull. Current Word 0x%x at pos 0x%x", *fDataWord, fPos));      
+         }; break;
+       case fkNextHC:
+       case fkSeekNonEoTracklet:
+       case fkDecodeHC:
+         {
+           if (DecodeHC() == kFALSE)
+             {
+               AliWarning(Form("Decode HC unsuccessfull. Current Word 0x%x at pos 0x%x", *fDataWord, fPos));     
+             }
+           else
+             {
+               //the hc header should be decoded by now
+               if (fLastStatus == fkDecodeHC)
+                 {
+                   fLastDET = fDET;
+                   fChamberDone[fDET]++;
+                 }
+             }
+         }; break;
+       case fkNextSM:
+         {
+           if (DecodeSM() == kFALSE)
+               AliWarning(Form("Decode SM unsuccessfull. Current Word 0x%x at pos 0x%x", *fDataWord, fPos));     
+         }; break;
+       case fkStop:
+         ; break;
+       default:
+         AliWarning(Form("Unknown state %d. Last state %d. Current Word 0x%x at pos 0x%x", fNextStatus, fLastStatus, *fDataWord, fPos));  
+         ChangeStatus(fkStop);
+       };
+
+    } // not fkStop
+
+  //AliDebug(1, Form("That's all folks! %d", fSM));
+  return kFALSE;
+}
+
+//____________________________________________________________________________
+Int_t AliTRDRawStreamV2::NextChamber(AliTRDdigitsManager *man)
+{
+  //
+  // Fills single chamber digit array 
+  // Return value is the detector number
+  //
+
+  AliTRDdataArrayI *digits = 0;
+  AliTRDdataArrayI *track0 = 0;
+  AliTRDdataArrayI *track1 = 0;
+  AliTRDdataArrayI *track2 = 0; 
+  AliTRDSignalIndex *indexes = 0;
+         
+  if (fNextStatus == fkStart)
+    {
+      Init();
+    }
+
+//   while (fNextStatus != fkStop)
+//     { // !fkStop
+//       NextData();
+//       // catch 3 things
+//       // 1) if end of raw data - if chamber complete return
+//       // 2) fill the data with signals if data decoded ok
+//       // 3) initialize (destroy old) after the det has changed -> just after HC header decoding
+//     } // not fkStop
+
+  while (fNextStatus != fkStop)
+    { // !fkStop
+      NextData();
+
+      switch (fNextStatus)
+       {
+         
+       case fkNextData:
+         {
+           if (DecodeNextRawWord() == kTRUE)
+             {
+               for (Int_t it = 0; it < 3; it++)
+                 {
+                   if ( fTB + it < fTBins )
+                     {
+                       if ( fSig[it] > fRawDigitThreshold )
+                         {
+                           digits->SetDataUnchecked(fROW, fCOL, fTB + it, fSig[it]);
+                           indexes->AddIndexTBin(fROW, fCOL, fTB + it);
+                           if (man->UsesDictionaries())
+                             {
+                               track0->SetDataUnchecked(fROW, fCOL, fTB + it, 0);
+                               track1->SetDataUnchecked(fROW, fCOL, fTB + it, 0);
+                               track2->SetDataUnchecked(fROW, fCOL, fTB + it, 0);
+                             } // if dictionaries
+                         } // signal above zero
+                     } // check the tbins range
+                 } // for each tbin of current 3             
+               fTB += 3;
+             }
+           else
+             {
+               // can be here as a fall back from decode raw data calling decodemcm
+               if (fEndOfDataFlag == kTRUE)
+                 {
+                   if (fChamberDone[fDET] == 2)
+                     {
+                       return fDET;
+                     }                         
+                   fEndOfDataFlag = kFALSE;
+                 }             
+             }
+         }; break;
+
+       case fkNextMCM:
+         {
+           if (DecodeMCM() == kFALSE)
+             {
+               AliWarning(Form("Decode MCM unsuccessfull. Current Word 0x%x at pos 0x%x", *fDataWord, fPos));    
+             }
+           // default place for end of raw data...
+           if (fEndOfDataFlag == kTRUE)
+             {
+               if (fChamberDone[fDET] == 2)
+                 {
+                   return fDET;
+                 }                             
+               fEndOfDataFlag = kFALSE;
+             }      
+         }; break;
+
+       case fkNextHC:
+       case fkSeekNonEoTracklet:
+       case fkDecodeHC:
+         {
+           if (DecodeHC() == kFALSE)
+             {
+               AliWarning(Form("Decode HC unsuccessfull. Current Word 0x%x at pos 0x%x", *fDataWord, fPos));     
+             }
+           else
+             {
+               //the hc header should be decoded by now
+               if (fLastStatus == fkDecodeHC)
+                 {
+//                 AliDebug(4, Form("???? New DET ???? %d last %d", fDET, fLastDET));
+                   // allocate stuff for the new det
+                   //man->ResetArrays();
+                   digits = man->GetDigits(fDET);
+                   track0 = man->GetDictionary(fDET,0);
+                   track1 = man->GetDictionary(fDET,1);
+                   track2 = man->GetDictionary(fDET,2);
+                   
+                   // Allocate memory space for the digits buffer
+                   if (digits->GetNtime() == 0) 
+                     {
+//                     AliDebug(5, Form("Alloc digits for det %d rows %d cols %d tbins %d", fDET, fRowMax, fColMax, fTBins));
+                       digits->Allocate(fRowMax, fColMax, fTBins);
+                       if (man->UsesDictionaries())
+                         {
+                           track0->Allocate(fRowMax, fColMax, fTBins);
+                           track1->Allocate(fRowMax, fColMax, fTBins);
+                           track2->Allocate(fRowMax, fColMax, fTBins);
+                         }
+                     }
+                   
+                   indexes = man->GetIndexes(fDET);
+                   indexes->SetSM(fSM);
+                   indexes->SetStack(fSTACK);
+                   indexes->SetLayer(fLAYER);
+                   indexes->SetDetNumber(fDET);
+                   
+                   if (indexes->IsAllocated() == kFALSE)
+                     {
+//                     AliDebug(4, "Allocating indexes");            
+                       indexes->Allocate(fRowMax, fColMax, fTBins);
+                     }
+                 } // is the HC header already decoded?
+             } // decode hc ok
+         }; break;
+
+       case fkNextSM:
+         {
+           if (DecodeSM() == kFALSE)
+             AliWarning(Form("Decode SM unsuccessfull. Current Word 0x%x at pos 0x%x", *fDataWord, fPos));       
+         }; break;
+
+       case fkStop:
+         ; break;
+
+       default:
+         AliWarning(Form("Unknown state %d. Last state %d. Current Word 0x%x at pos 0x%x", fNextStatus, fLastStatus, *fDataWord, fPos));  
+         ChangeStatus(fkStop);
+       };
+
+    } // not fkStop
+
+  // we do not return chambers for which the end-of-data was not received twice (for each HC)
+
+  //AliDebug(1, Form("That's all folks! %d", fSM));
+  //return kFALSE;
+  return -1;
+}
diff --git a/TRD/AliTRDRawStreamV2.h b/TRD/AliTRDRawStreamV2.h
new file mode 100644 (file)
index 0000000..bd95018
--- /dev/null
@@ -0,0 +1,217 @@
+#ifndef ALITRDRAWSTREAMV2_H
+#define ALITRDRAWSTREAMV2_H
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                               */
+
+/* $Id$ */
+
+///////////////////////////////////////////////////////////////////////////////
+//                                                                           //
+// This class provides access to TRD digits in raw data.                     //
+//                                                                           //
+///////////////////////////////////////////////////////////////////////////////
+
+#include <TObject.h>
+
+class AliTRDgeometry;
+class AliRawReader;
+class AliTRDdigitsManager;
+
+class AliTRDRawStreamV2: public TObject {
+
+  public :
+
+    AliTRDRawStreamV2();
+    AliTRDRawStreamV2(AliRawReader *rawReader);
+    virtual ~AliTRDRawStreamV2();
+
+    virtual Bool_t       Next();              // Read the next data
+    virtual Int_t NextChamber(AliTRDdigitsManager *man); // read next chamber data
+    virtual Int_t        Init();              // Init for the fRawVersion > 1
+
+    enum { kDDLOffset = 0x400 };              // Offset for DDL numbers
+
+    Bool_t               SetRawVersion(Int_t rv);
+    Int_t                GetRawVersion() const                      { return fRawVersion;     };
+    void                 SetRawReader(AliRawReader *rawReader);
+
+    // Get Filter settings (does not make a lot of sense):
+    Int_t                TRAPfilterTCon() const                     { return fTCon;           };
+    Int_t                TRAPfilterPEDon() const                    { return fPEDon;          };
+    Int_t                TRAPfilterGAINon() const                   { return fGAINon;         };
+    Int_t                TRAPsendsUnfilteredData() const            { return fBypass;         };
+
+    // Get Tracklet parameters (does not make a lot of sense):
+    Float_t              GetTrackletPID() const                     { return fTracklPID;      };
+    Float_t              GetTrackletDeflLength() const              { return fTracklDefL;     };
+    Float_t              GetTrackletPadPos() const                  { return fTracklPadPos;   };
+    Int_t                GetTrackletPadRow() const                  { return fTracklPadRow;   };
+
+    // Check if the link has optical power (HC sends data)
+    Bool_t               IsGTULinkActive(Int_t sm, Int_t la, Int_t sta, Int_t side)
+      { return ( ((fGTUlinkMask[sm][sta]) >> (2*la+side)) & 0x1 ); };
+
+    Int_t *GetSignals() { return fSig;}                         //  Signals in the three time bins from Data Word
+    Int_t GetADC() const { return fADC;}                            //  MCM ADC channel and Time Bin of word 1
+    Int_t GetTimeBin() const { return fTB - 3;}                             //  MCM ADC channel and Time Bin of word 1
+    Int_t GetEventNumber() const { return fEv;}                             //  MCM Event number and position of current MCM on TRD chamber
+    Int_t GetROB() const { return fROB;}                            //  MCM Event number and position of current MCM on TRD chamber
+    Int_t GetMCM() const { return fMCM;}                           //  MCM Event number and position of current MCM on TRD chamber
+    Int_t GetSM() const { return fSM;}                             //  Position of CURRENT half chamber in full TRD
+    Int_t GetLayer() const { return fLAYER;}                          //  PLANE = Position of CURRENT half chamber in full TRD
+    Int_t GetStack() const { return fSTACK;}                          //  CHAMBER = Position of CURRENT half chamber in full TRD
+    Int_t GetROC() const { return fROC;}                            //  Position of CURRENT half chamber in full TRD
+    Int_t GetSide() const { return fSIDE;}                           //  Position of CURRENT half chamber in full TRD
+    Int_t GetDCS() const { return fDCS;}                            //  DCS board number read from data (HC header)
+    Int_t GetRow() const { return fROW;}
+    Int_t GetCol() const { return fCOL;}                            //  Detector Pad coordinates
+    Int_t GetDet() const { return fDET;} // helper
+    Int_t GetLastDet() const { return fLastDET;} // helper
+    Int_t GetMaxRow() const { return fRowMax;}
+    Int_t GetMaxCol() const { return fColMax;}
+    Int_t GetNumberOfTimeBins() const {return fTBins;}
+
+  private :
+
+    Int_t    fSig[3];                         //  Signals in the three time bins from Data Word
+    Int_t    fADC;                            //  MCM ADC channel and Time Bin of word 1
+    Int_t    fTB;                             //  MCM ADC channel and Time Bin of word 1
+    Int_t    fEv;                             //  MCM Event number and position of current MCM on TRD chamber
+    Int_t    fROB;                            //  MCM Event number and position of current MCM on TRD chamber
+    Int_t    fMCM;                            //  MCM Event number and position of current MCM on TRD chamber
+    Int_t    fSM;                             //  Position of CURRENT half chamber in full TRD
+    Int_t    fLAYER;                          //  Position of CURRENT half chamber in full TRD
+    Int_t    fSTACK;                          //  Position of CURRENT half chamber in full TRD
+    Int_t    fROC;                            //  Position of CURRENT half chamber in full TRD
+    Int_t    fSIDE;                           //  Position of CURRENT half chamber in full TRD
+    Int_t    fDCS;                            //  DCS board number read from data (HC header)
+    Int_t    fROW;                            //  Detector Row coordinates
+    Int_t    fCOL;                            //  Detector Pad coordinates
+    Int_t    fDET;                            //  Current detector - version > 1
+    Int_t    fLastDET;                        //  Previous detector - version > 1
+
+    Int_t    fBCctr;                          //  Counters from HC header (>=V2)
+    Int_t    fPTctr;                          //  Counters from HC header (>=V2)
+    Int_t    fPTphase;                        //  Counters from HC header (>=V2)
+    Int_t    fRVmajor;                        //  Raw version numbers and number of additional HC headerwords (>=V2)
+    Int_t    fRVminor;                        //  Raw version numbers and number of additional HC headerwords (>=V2)
+    Int_t    fHCHWords;                       //  Raw version numbers and number of additional HC headerwords (>=V2)
+    Int_t    fTBins;                          //  Number of time bins read from HC header (>=V2)
+    Bool_t   fTCon;                           //  Filter settings read from HC header (>=V2)
+    Bool_t   fPEDon;                          //  Filter settings read from HC header (>=V2)
+    Bool_t   fGAINon;                         //  Filter settings read from HC header (>=V2)
+    Bool_t   fXTon;                           //  Filter settings read from HC header (>=V2)
+    Bool_t   fNonLinOn;                       //  Filter settings read from HC header (>=V2)
+    Bool_t   fBypass;                         //  Filter settings read from HC header (>=V2)
+    Int_t    fCommonAdditive;                 //  Common baseline additive read from HC header (>=V2)
+
+    Bool_t   fZeroSuppressed;                 // Data is zero suppressed
+
+    Int_t    fHCHctr1;                        //  HC and MCM Header counter
+    Int_t    fHCHctr2;                        //  HC and MCM Header counter
+    Int_t    fMCMHctr1;                       //  HC and MCM Header counter
+    Int_t    fMCMHctr2;                       //  HC and MCM Header counter
+    Int_t    fGTUctr1;                        //  GTU LinkMask Counter
+    Int_t    fGTUctr2;                        //  GTU LinkMask Counter
+    Int_t    fHCdataCtr;                      //  Data Counter for half chamber
+    
+    Float_t  fTracklPID;                      //  Tracklet parameters
+    Float_t  fTracklDefL;                     //  Tracklet parameters
+    Float_t  fTracklPadPos;                   //  Tracklet parameters
+    Int_t    fTracklPadRow;                   //  Tracklet parameters
+
+    UShort_t fGTUlinkMask[18][5];             //  Mask with active links
+
+    Int_t    fMCMWordCrt;                     //  Word Counter for a single MCM
+    Int_t    fMCMWordsExpected;                //  Expected Words from MCM 
+
+    AliTRDRawStreamV2(const AliTRDRawStreamV2 &stream);
+    AliTRDRawStreamV2 &operator=(const AliTRDRawStreamV2 &stream);
+
+    AliRawReader *fRawReader;              //  Object for reading the raw data
+
+    Int_t    fRawVersion;                  //  Which version of raw data decoding is used
+    Int_t    fRawDigitThreshold;           //  Naive "zero"(threshold) supression. Usefull for Raw Data ver 2.
+
+    Int_t    fNextStatus;                  //  Navigation in raw versions > 1
+    Int_t    fLastStatus;                  //  Navigation in raw versions > 1
+    UInt_t   fTbSwitch;                    //  Time Bin Switch for internal use
+    UInt_t   fTbSwitchCtr;                 //  Counter for internal use
+    UInt_t   fTimeWords;                   //  Number of Words needed to store the data of 1 ADC ch.
+    UInt_t   fWordCtr;                     //  Word Counter
+
+    Int_t    fRowMax;                      //  Maximum number of pad rows and columns
+    Int_t    fColMax;                      //  Maximum number of pad rows and columns
+
+    Bool_t   fADCmask[21];                 //  Mask of active ADCs for zero suppression
+    UInt_t   fLastADCmask;                 //  Last ADC read out
+
+    UShort_t fChamberDone[540];            //  Chamber was processed already (1=1HC, 2=full chamber)
+
+    Int_t    fRetVal;                      //  Datadecode return
+    Int_t    fEqID;                        //  Equipment id
+    UInt_t   fDataSize;                    //  Size of the data available in the current buffer
+    Bool_t   fSizeOK;                      //  Did we read anything
+    UInt_t   fCountBytes;                  //  Bytes traversed in the buffer
+    UInt_t   fBufSize;                     //  Size of the current RawReader buffer
+    Bool_t   fkBufferSet;                  //  Is the RawReader buffer available
+    UChar_t *fPos;                         //  Position in the buffer of the RawReader
+    UInt_t  *fDataWord;                    //  The pointer to the current 32 bit data word
+    UInt_t   fTimeBinsCalib;               //  N of time bins retrieved from calibration
+
+    Int_t    fADClookup[32];               //  Lookup for version 3 (1[entries]+1[index]+30[fADC channels] = 32)
+    Int_t    fNActiveADCs;                 //  Number of active ADC channels
+    Bool_t   fEndOfDataFlag;               //  End of data flag
+
+    enum ETRDzRawStreamError {
+       kHCWordMissing = 1                  //
+      ,kMCMADCMaskMissing = 2              //
+      ,kWrongMCMorROB = 3                  //
+      ,kGTULinkMaskMissing = 4             //
+      ,kHCHeaderCorrupt = 5                //
+      ,kHCHeaderMissing = 6                //
+      ,kROBSideMismatch = 7                //
+      ,kWrongPadrow = 8                    //
+      ,kWrongPadcolumn = 9                 //
+      ,kTrackletRowMismatch = 10           //
+      ,kDataMaskError = 11                 //
+      ,kADCNumberOverflow = 12             //
+      ,kADCChannelOverflow = 13            //
+    };
+
+ protected:
+
+    AliTRDgeometry *fGeo;                  //  TRD geometry
+
+    Bool_t DecodeGTUlinkMask();
+    Bool_t DecodeNextRawWord();
+    Bool_t DecodeMCM();
+    Bool_t DecodeHC();
+    Bool_t DecodeSM();
+    inline void  ChangeStatus(Int_t kstat);
+/*       { */
+/*     fLastStatus = fNextStatus; */
+/*     fNextStatus = kstat;   */
+/*       } */
+
+    void  DecodeHCheader(Int_t timeBins = 0);
+    void  DecodeMCMheader();
+    void  DecodeTracklet();
+
+    void  SetRawDigitThreshold (Int_t ith) {fRawDigitThreshold = ith;} // set the naive zero suppression threshold
+
+    Int_t NextData(); // get the next piece of memory
+
+    Int_t  ChannelsToRead(Int_t ADCmask); // Get the active ADC channels from the mask (V3 and 2)
+
+    enum { fkStart, fkStop, fkWordOK, fkNoMoreData, fkNextSM, fkNextHC, fkSeekNonEoTracklet, fkDecodeHC, fkNextMCM, fkNextData, fkReading};
+
+    // Some constants:
+    static const UInt_t kEndoftrackletmarker = 0xAAAAAAAA; /*This marks the end of tracklet data words*/
+    static const UInt_t kEndofrawdatamarker  = 0x00000000; /*This marks the end of half-chamber-data*/
+    static const UInt_t kSizeWord = sizeof(UInt_t); // size of a word in bytes
+    
+    ClassDef(AliTRDRawStreamV2, 1)               // Class for reading TRD raw digits
+
+};
+#endif
index 58ea955..d39b371 100644 (file)
@@ -32,7 +32,6 @@
 #include "AliTRDReconstructor.h"
 #include "AliTRDclusterizerV1.h"
 #include "AliTRDclusterizerV2.h"
-//#include "AliTRDclusterizerV2xMP.h"
 #include "AliTRDtracker.h"
 #include "AliTRDpidESD.h"
 #include "AliTRDgtuTrack.h"
@@ -129,7 +128,6 @@ void AliTRDReconstructor::Reconstruct(AliRawReader *rawReader
   clusterer.OpenOutput(clusterTree);
   clusterer.SetAddLabels(kFALSE);
   clusterer.Raw2ClustersChamber(rawReader);
-
 }
 
 //_____________________________________________________________________________
@@ -141,12 +139,11 @@ void AliTRDReconstructor::Reconstruct(TTree *digitsTree
   //
   AliInfo("Reconstruct TRD clusters from Digits [Digit TTree -> Cluster TTree]");
 
-  AliTRDclusterizerV1 clusterer("clusterer","TRD clusterizer");
-  //AliTRDclusterizerV2 clusterer("clusterer","TRD clusterizer");
+  //AliTRDclusterizerV1 clusterer("clusterer","TRD clusterizer");
+  AliTRDclusterizerV2 clusterer("clusterer","TRD clusterizer");
   clusterer.OpenOutput(clusterTree);
   clusterer.ReadDigits(digitsTree);
   clusterer.MakeClusters();
-
 }
 
 //_____________________________________________________________________________
index a5ad8f1..d95628c 100644 (file)
@@ -267,7 +267,8 @@ void AliTRDSignalIndex::AddIndexTBin(Int_t row, Int_t col, Int_t tbin)
   // the RC index is updated to!!!
   // this is to be used in the TRD clusterizer!
 
-  if (fPositionCol + fNtbins >= fMaxLimit)
+  //if (fPositionCol + fNtbins >= fMaxLimit)
+  if (row * col * tbin + row * col * 2 >= fMaxLimit)
     {
       AliError(Form("Out-of-limits fPositionCol + fNtbins %d. Limit is: %d", fPositionCol + fNtbins, fMaxLimit));
       return;
@@ -294,9 +295,8 @@ void AliTRDSignalIndex::AddIndexTBin(Int_t row, Int_t col, Int_t tbin)
       (*fIndex)[fPositionRow] = row;
       (*fIndex)[fPositionCol] = col;
       (*fIndex)[fPositionCol + fPositionTbin] = tbin;
-
+      //AliInfo(Form("x1: fPositionCol + fPositionTbin = %d", fPositionCol + fPositionTbin));
       ++fPositionTbin;
-      //AliDebug(3, Form("fNRCindexed=%d", fNRCindexed));
     }
   else
     {
@@ -307,6 +307,7 @@ void AliTRDSignalIndex::AddIndexTBin(Int_t row, Int_t col, Int_t tbin)
       //       }
       
       (*fIndex)[fPositionCol + fPositionTbin] = tbin;
+      //AliInfo(Form("x2: fPositionCol + fPositionTbin = %d", fPositionCol + fPositionTbin));
       ++fPositionTbin;      
     }
   
@@ -322,19 +323,13 @@ Bool_t  AliTRDSignalIndex::NextRCIndex(Int_t &row, Int_t &col)
 {
   // return the position (index in the data array) of the next available pad
 
-  if (fPositionCol + fNtbins >= fMaxLimit)
-    {
-      //AliDebug(8, "Out of index range");
-      return kFALSE;
-    }
-
   if (fResetCounters == kTRUE)
     {
       fPositionRow = 0;
       fPositionCol = 1;
       
       fResetCounters = kFALSE;
-      AliDebug(2, "Reset counters");
+      //AliDebug(2, "Reset counters");
     }
   else
     {
@@ -342,6 +337,12 @@ Bool_t  AliTRDSignalIndex::NextRCIndex(Int_t &row, Int_t &col)
       fPositionCol += fNtbins + 2;
     }
 
+  if (fPositionRow >= fMaxLimit)
+    {
+      //AliDebug(8, "Out of index range");
+      return kFALSE;
+    }
+
   //AliDebug(8, Form("Next RC %d", fPositionRow / (fNtbins + 2)));
 
   fPositionTbin = 1;
@@ -361,11 +362,9 @@ Bool_t  AliTRDSignalIndex::NextRCTbinIndex(Int_t &row, Int_t &col, Int_t &tbin)
   // return the position (index in the data array) of the next available tbin 
   // within the current pad
 
-//   if (fNRCcounter >= fNRCindexed)
-//     return kFALSE;
-
-  if (fPositionCol + fNtbins >= fMaxLimit)
+  if (fPositionRow >= fMaxLimit)
     {
+      //AliDebug(8, "Out of index range");
       return kFALSE;
     }
 
@@ -380,7 +379,6 @@ Bool_t  AliTRDSignalIndex::NextRCTbinIndex(Int_t &row, Int_t &col, Int_t &tbin)
     {
       if (NextRCIndex(row, col))
        {
-         //return NextTbinIndex(tbin);
          return NextRCTbinIndex(row, col, tbin);
        }
     }
@@ -394,11 +392,9 @@ Bool_t  AliTRDSignalIndex::NextTbinIndex(Int_t &tbin)
   // return the position (index in the data array) of the next available tbin 
   // within the current pad
 
-//   if (fNRCcounter >= fNRCindexed)
-//     return kFALSE;
-
-  if (fPositionCol + fNtbins >= fMaxLimit || fPositionTbin > fNtbins)
+  if (fPositionCol + fPositionTbin >= fMaxLimit || fPositionTbin > fNtbins)
     {
+      //AliDebug(8, "Out of index range");
       return kFALSE;
     }
 
index 9784215..2f23bf4 100644 (file)
@@ -82,7 +82,6 @@ AliTRDSimParam::AliTRDSimParam()
   ,fChipGain(0.0)
   ,fADCoutRange(0.0)
   ,fADCinRange(0.0)
-  ,fADCthreshold(0)
   ,fADCbaseline(0)
   ,fDiffusionOn(kFALSE)
   ,fElAttachOn(kFALSE)
@@ -122,9 +121,8 @@ void AliTRDSimParam::Init()
   fNoise             = 1250.0;
   fADCoutRange       = 1023.0;          // 10-bit ADC
   fADCinRange        = 2000.0;          // 2V input range
-  fADCthreshold      =    3;
   // Go back to 0 again, just to be consistent with reconstruction
-  fADCbaseline       =    0;
+  fADCbaseline       =      0;
   //fADCbaseline       =   10;
 
   // Diffusion on
@@ -188,7 +186,6 @@ AliTRDSimParam::AliTRDSimParam(const AliTRDSimParam &p)
   ,fChipGain(p.fChipGain)
   ,fADCoutRange(p.fADCoutRange)
   ,fADCinRange(p.fADCinRange)
-  ,fADCthreshold(p.fADCthreshold)
   ,fADCbaseline(p.fADCbaseline)
   ,fDiffusionOn(p.fDiffusionOn)
   ,fElAttachOn(p.fElAttachOn)
@@ -263,7 +260,6 @@ void AliTRDSimParam::Copy(TObject &p) const
   target->fChipGain           = fChipGain;  
   target->fADCoutRange        = fADCoutRange;
   target->fADCinRange         = fADCinRange;
-  target->fADCthreshold       = fADCthreshold;
   target->fADCbaseline        = fADCbaseline; 
   target->fDiffusionOn        = fDiffusionOn; 
   target->fElAttachOn         = fElAttachOn;
index eb6d047..74efc34 100644 (file)
@@ -35,7 +35,7 @@ class AliTRDSimParam : public TObject {
           void     SetChipGain(Float_t chipgain)             { fChipGain          = chipgain;        }
           void     SetADCoutRange(Float_t range)             { fADCoutRange       = range;           }
           void     SetADCinRange(Float_t range)              { fADCinRange        = range;           }
-          void     SetADCthreshold(Int_t thresh)             { fADCthreshold      = thresh;          }
+//        void     SetADCthreshold(Int_t thresh)             { fADCthreshold      = thresh;          }
           void     SetADCbaseline(Int_t basel)               { fADCbaseline       = basel;           }   
           void     SetDiffusion(Int_t diffOn = 1)            { fDiffusionOn       = diffOn;          }
           void     SetElAttach(Int_t elOn = 1)               { fElAttachOn        = elOn;            }
@@ -53,7 +53,7 @@ class AliTRDSimParam : public TObject {
           Float_t  GetChipGain() const                       { return fChipGain;                     }
           Float_t  GetADCoutRange() const                    { return fADCoutRange;                  }
           Float_t  GetADCinRange() const                     { return fADCinRange;                   }
-          Int_t    GetADCthreshold() const                   { return fADCthreshold;                 }
+//        Int_t    GetADCthreshold() const                   { return fADCthreshold;                 }
           Int_t    GetADCbaseline() const                    { return fADCbaseline;                  }
           Float_t  GetTRFlo() const                          { return fTRFlo;                        }
           Float_t  GetTRFhi() const                          { return fTRFhi;                        }
@@ -85,8 +85,8 @@ protected:
   
           Float_t  fADCoutRange;       //  ADC output range (number of channels)
           Float_t  fADCinRange;        //  ADC input range (input charge)
-          Int_t    fADCthreshold;      //  ADC threshold in ADC channel
-          Int_t    fADCbaseline;       //  ADC baseline in ADC chann
+          // Int_t    fADCthreshold;   //  ADC threshold in ADC channel ... Obsolete
+          Int_t    fADCbaseline;       //  ADC intrinsic baseline in ADC channel
   
           Int_t    fDiffusionOn;       //  Switch for the diffusion
   
index 4f493ba..18b4151 100644 (file)
@@ -224,7 +224,7 @@ Bool_t AliTRDclusterizer::WriteClusters(Int_t det)
         detRecPoints->AddLast(c);
       }
       else {
-        AliError("Attempt to write a cluster with unexpected detector index\n");
+        AliError(Form("Attempt to write a cluster with unexpected detector index: got=%d expected=%d\n", c->GetDetector(), det));
       }
     }
 
@@ -233,6 +233,8 @@ Bool_t AliTRDclusterizer::WriteClusters(Int_t det)
 
     delete detRecPoints;
 
+    //AliInfo(Form("Writing %d clusters to tree", nRecPoints));
+    
     return kTRUE;
 
   }
index 9c91861..4b7f245 100644 (file)
@@ -211,7 +211,8 @@ Bool_t AliTRDclusterizerV1::MakeClusters()
   }
 
   // ADC thresholds
-  Float_t ADCthreshold   = simParam->GetADCthreshold();
+  // Float_t ADCthreshold   = simParam->GetADCthreshold();
+  Float_t ADCthreshold   = 0;
   // Threshold value for the maximum
   Float_t maxThresh      = recParam->GetClusMaxThresh();
   // Threshold value for the digit signal
index b00db7d..eb1d763 100644 (file)
@@ -50,6 +50,9 @@
 
 #include "AliTRDSignalIndex.h"
 #include "AliTRDRawStream.h"
+#include "AliTRDRawStreamV2.h"
+
+#include "AliTRDfeeParam.h"
 
 ClassImp(AliTRDclusterizerV2)
 
@@ -67,6 +70,7 @@ AliTRDclusterizerV2::AliTRDclusterizerV2()
   // AliTRDclusterizerV2 default constructor
   //
 
+  fRawVersion = AliTRDfeeParam::Instance()->GetRAWversion();
 }
 
 //_____________________________________________________________________________
@@ -85,6 +89,8 @@ AliTRDclusterizerV2::AliTRDclusterizerV2(const Text_t *name, const Text_t *title
 
   fDigitsManager->CreateArrays();
   fGeometry = new AliTRDgeometry;
+
+  fRawVersion = AliTRDfeeParam::Instance()->GetRAWversion();
 }
 
 //_____________________________________________________________________________
@@ -272,6 +278,7 @@ Bool_t AliTRDclusterizerV2::MakeClusters()
          fDigitsManager->BuildIndexes(i);
        }
 
+      Bool_t fR = kFALSE;
       if (indexes->HasEntry())
        {
          if (fAddLabels)
@@ -283,9 +290,15 @@ Bool_t AliTRDclusterizerV2::MakeClusters()
                  tracksIn->Expand();
                }
            }
-         Bool_t fR = MakeClusters(i);
+         fR = MakeClusters(i);
          fReturn = fR && fReturn;
        }
+
+      if (fR == kFALSE)
+       {
+         WriteClusters(i);
+         ResetRecPoints();
+       }
       //digitsIn->Compress(1,0);
       // no compress just remove
       fDigitsManager->RemoveDigits(i);
@@ -319,10 +332,13 @@ Bool_t AliTRDclusterizerV2::Raw2Clusters(AliRawReader *rawReader)
       fDigitsManager->CreateArrays();
     }
 
-  AliTRDRawStream input(rawReader);
+  //AliTRDRawStream input(rawReader);
+  AliTRDRawStreamV2 input(rawReader);
   input.SetRawVersion( fRawVersion );
   input.Init();
 
+  AliInfo(Form("Stream version: %s", input.IsA()->GetName()));
+
   // Loop through the digits
   Int_t lastdet = -1;
   Int_t det    = 0;
@@ -337,8 +353,14 @@ Bool_t AliTRDclusterizerV2::Raw2Clusters(AliRawReader *rawReader)
          if (lastdet != -1)
            {
              digits = fDigitsManager->GetDigits(lastdet);
+             Bool_t iclusterBranch = kFALSE;
              if (indexes->HasEntry())
-               MakeClusters(lastdet);
+               iclusterBranch = MakeClusters(lastdet);
+             if (iclusterBranch == kFALSE)
+               {
+                 WriteClusters(lastdet);
+                 ResetRecPoints();
+               }
            }
 
          if (digits)
@@ -399,7 +421,15 @@ Bool_t AliTRDclusterizerV2::Raw2Clusters(AliRawReader *rawReader)
 
   if (lastdet != -1)
     {
-      MakeClusters(lastdet);
+      Bool_t iclusterBranch = kFALSE;
+      if (indexes->HasEntry())
+       iclusterBranch = MakeClusters(lastdet);
+      if (iclusterBranch == kFALSE)
+       {
+         WriteClusters(lastdet);
+         ResetRecPoints();
+       }
+      //MakeClusters(lastdet);
       if (digits)
        {
          fDigitsManager->RemoveDigits(lastdet);
@@ -432,15 +462,24 @@ Bool_t AliTRDclusterizerV2::Raw2ClustersChamber(AliRawReader *rawReader)
 
   fDigitsManager->SetUseDictionaries(fAddLabels);
 
-  AliTRDRawStream input(rawReader);
+  //AliTRDRawStream input(rawReader);
+  AliTRDRawStreamV2 input(rawReader);
   input.SetRawVersion( fRawVersion );
   input.Init();
+
+  AliInfo(Form("Stream version: %s", input.IsA()->GetName()));
   
   Int_t det    = 0;
   while ((det = input.NextChamber(fDigitsManager)) >= 0)
     {
+      Bool_t iclusterBranch = kFALSE;
       if (fDigitsManager->GetIndexes(det)->HasEntry())
-       MakeClusters(det);
+       iclusterBranch = MakeClusters(det);
+      if (iclusterBranch == kFALSE)
+       {
+         WriteClusters(det);
+         ResetRecPoints();
+       }
       fDigitsManager->RemoveDigits(det);
       fDigitsManager->RemoveDictionaries(det);      
       fDigitsManager->ClearIndexes(det);
@@ -495,7 +534,9 @@ Bool_t AliTRDclusterizerV2::MakeClusters(Int_t det)
   }
 
   // ADC thresholds
-  Float_t ADCthreshold   = simParam->GetADCthreshold();
+  //  Float_t ADCthreshold   = simParam->GetADCthreshold();
+  Float_t ADCthreshold   = 0; // There is no ADC threshold anymore, and simParam should not be used ni clusterizer. KO
+
   // Threshold value for the maximum
   Float_t maxThresh      = recParam->GetClusMaxThresh();
   // Threshold value for the digit signal
@@ -1000,6 +1041,7 @@ void AliTRDclusterizerV2::Transform(AliTRDdataArrayI *digitsIn
       if (recParam->TCOn()) {
        DeConvExp(inADC,outADC,nTimeTotal,recParam->GetTCnexp());
       }
+
       indexesIn->ResetTbinCounter();
       while (indexesIn->NextTbinIndex(iTime))
        {
index a3438eb..acd2d6f 100644 (file)
@@ -31,7 +31,6 @@
 //      - Electronics noise                                                  //
 //      - Electronics gain                                                   //
 //      - Digitization                                                       //
-//      - ADC threshold                                                      //
 //  The corresponding parameter can be adjusted via the various              //
 //  Set-functions. If these parameters are not explicitly set, default       //
 //  values are used (see Init-function).                                     //
@@ -73,6 +72,7 @@
 #include "AliTRDcalibDB.h"
 #include "AliTRDSimParam.h"
 #include "AliTRDCommonParam.h"
+#include "AliTRDfeeParam.h"
 
 #include "Cal/AliTRDCalROC.h"
 #include "Cal/AliTRDCalDet.h"
@@ -88,6 +88,7 @@ AliTRDdigitizer::AliTRDdigitizer()
   ,fSDigitsManagerList(0)
   ,fTRD(0)
   ,fGeo(0)
+  ,fFee(0)
   ,fEvent(0)
   ,fMasks(0)
   ,fCompress(kTRUE)
@@ -122,6 +123,7 @@ AliTRDdigitizer::AliTRDdigitizer(const Text_t *name, const Text_t *title)
   ,fSDigitsManagerList(0)
   ,fTRD(0)
   ,fGeo(0)
+  ,fFee(0)
   ,fEvent(0)
   ,fMasks(0)
   ,fCompress(kTRUE)
@@ -157,6 +159,7 @@ AliTRDdigitizer::AliTRDdigitizer(AliRunDigitizer *manager
   ,fSDigitsManagerList(0)
   ,fTRD(0)
   ,fGeo(0)
+  ,fFee(0)
   ,fEvent(0)
   ,fMasks(0)
   ,fCompress(kTRUE)
@@ -191,6 +194,7 @@ AliTRDdigitizer::AliTRDdigitizer(AliRunDigitizer *manager)
   ,fSDigitsManagerList(0)
   ,fTRD(0)
   ,fGeo(0)
+  ,fFee(0)
   ,fEvent(0)
   ,fMasks(0)
   ,fCompress(kTRUE)
@@ -229,6 +233,7 @@ Bool_t AliTRDdigitizer::Init()
   fSDigitsManagerList = 0;
   fTRD                = 0;
   fGeo                = 0;
+  fFee                = AliTRDfeeParam::Instance();
 
   fEvent              = 0;
   fMasks              = 0;
@@ -261,6 +266,7 @@ AliTRDdigitizer::AliTRDdigitizer(const AliTRDdigitizer &d)
   ,fSDigitsManagerList(0)
   ,fTRD(0)
   ,fGeo(0)
+  ,fFee(0)
   ,fEvent(0)
   ,fMasks(0)
   ,fCompress(d.fCompress)
@@ -366,6 +372,7 @@ void AliTRDdigitizer::Copy(TObject &d) const
   ((AliTRDdigitizer &) d).fSDigitsManagerList = 0;
   ((AliTRDdigitizer &) d).fTRD                = 0;
   ((AliTRDdigitizer &) d).fGeo                = 0;
+  ((AliTRDdigitizer &) d).fFee                = fFee;
   ((AliTRDdigitizer &) d).fEvent              = 0;
   ((AliTRDdigitizer &) d).fMasks              = 0;
   ((AliTRDdigitizer &) d).fCompress           = fCompress;
@@ -1285,7 +1292,8 @@ Bool_t AliTRDdigitizer::MakeDigits()
 
             for (iTime = 0; iTime < nTimeTotal; iTime++) {   
               // Store the amplitude of the digit if above threshold
-              if (outADC[iTime] > (simParam->GetADCbaseline() + simParam->GetADCthreshold())) {
+              // if (outADC[iTime] > (simParam->GetADCbaseline() + simParam->GetADCthreshold())) {
+              if (outADC[iTime] != 0 ) {   // Now this is enough because there is ZS in raw simulator
                 nDigits++;
                 digits->SetDataUnchecked(iRow,iCol,iTime,((Int_t) outADC[iTime]));
              }
@@ -1404,7 +1412,6 @@ Bool_t AliTRDdigitizer::ConvertSDigits()
   Double_t convert      = kEl2fC * chipGain;
   Double_t adcInRange   = simParam->GetADCinRange();
   Double_t adcOutRange  = simParam->GetADCoutRange();
-  Int_t    adcThreshold = simParam->GetADCthreshold();
   Int_t    adcBaseline  = simParam->GetADCbaseline();   
   Int_t    nTimeTotal   = calibration->GetNumberOfTimeBins();
 
@@ -1495,7 +1502,8 @@ Bool_t AliTRDdigitizer::ConvertSDigits()
 
           for (iTime = 0; iTime < nTimeTotal; iTime++) {
             // Store the amplitude of the digit if above threshold
-            if (outADC[iTime] > (adcBaseline + adcThreshold)) {
+            // if (outADC[iTime] > (adcBaseline + adcThreshold)) {
+           if (outADC[iTime] != 0) {  // now this is ok because there is ZS in raw simulation
               digitsOut->SetDataUnchecked(iRow,iCol,iTime,((Int_t) outADC[iTime]));
              // Copy the dictionary
               for (iDict = 0; iDict < kNDict; iDict++) { 
index c27a391..fd5f644 100644 (file)
@@ -22,6 +22,7 @@ class AliRunLoader;
 class AliTRD;
 class AliTRDdigitsManager;
 class AliTRDgeometry;
+class AliTRDfeeParam;
 
 class AliTRDdigitizer : public AliDigitizer {
 
@@ -84,6 +85,7 @@ class AliTRDdigitizer : public AliDigitizer {
   TList               *fSDigitsManagerList; //! List of managers of input s-digits
   AliTRD              *fTRD;                //! TRD detector class
   AliTRDgeometry      *fGeo;                //! TRD geometry
+  AliTRDfeeParam      *fFee;                //  Fee Parameters
 
           Int_t    fEvent;                  //! Event number
           Int_t   *fMasks;                  //! Masks for the merging
index f4b540a..c6d50b5 100644 (file)
 
 /* $Id$ */
 
+/*
+
+  New release on 2007/08/17
+
+The default raw data version (now fRAWversion ) is set to 3
+in the constructer because version 3 raw data read and write
+are fully debugged.
+
+*/
+
 //////////////////////////////////////////////////
 //                                              //
 //  TRD front end electronics parameters class  //
@@ -26,6 +36,7 @@
 
 #include <TMath.h>
 
+#include "AliLog.h"
 #include "AliTRDfeeParam.h"
 #include "AliTRDgeometry.h"
 #include "AliTRDCommonParam.h"
@@ -75,6 +86,8 @@ AliTRDfeeParam::AliTRDfeeParam()
   ,fTFr2(0)
   ,fTFc1(0)
   ,fTFc2(0)
+  ,fRAWversion(3)
+  ,fRAWstoreRaw(kTRUE)
 {
   //
   // Default constructor
@@ -108,6 +121,8 @@ AliTRDfeeParam::AliTRDfeeParam(const AliTRDfeeParam &p)
   ,fTFr2(p.fTFr2)
   ,fTFc1(p.fTFc1)
   ,fTFc2(p.fTFc2)
+  ,fRAWversion(p.fRAWversion)
+  ,fRAWstoreRaw(p.fRAWstoreRaw)
 {
   //
   // AliTRDfeeParam copy constructor
@@ -143,11 +158,13 @@ void AliTRDfeeParam::Copy(TObject &p) const
   //
 
   //  ((AliTRDfeeParam &) p).fGeo     = fGeo;
-  ((AliTRDfeeParam &) p).fCP      = fCP;
-  ((AliTRDfeeParam &) p).fTFr1   = fTFr1;
-  ((AliTRDfeeParam &) p).fTFr2   = fTFr2;
-  ((AliTRDfeeParam &) p).fTFc1   = fTFc1;
-  ((AliTRDfeeParam &) p).fTFc2   = fTFc2;
+  ((AliTRDfeeParam &) p).fCP          = fCP;
+  ((AliTRDfeeParam &) p).fTFr1        = fTFr1;
+  ((AliTRDfeeParam &) p).fTFr2        = fTFr2;
+  ((AliTRDfeeParam &) p).fTFc1        = fTFc1;
+  ((AliTRDfeeParam &) p).fTFc2        = fTFc2;
+  ((AliTRDfeeParam &) p).fRAWversion  = fRAWversion;
+  ((AliTRDfeeParam &) p).fRAWstoreRaw = fRAWstoreRaw;
   
   TObject::Copy(p);
 }
@@ -166,17 +183,21 @@ Int_t AliTRDfeeParam::GetPadRowFromMCM(Int_t irob, Int_t imcm) const
 Int_t AliTRDfeeParam::GetPadColFromADC(Int_t irob, Int_t imcm, Int_t iadc) const
 {
   //
-  // return which pad is connected to this adc channel.
-  // Return -1 if no appropriate pad is found.
-
+  // Return which pad is connected to this adc channel.
+  //
+  // Return virtual pad number even if ADC is outside chamber
+  // to keep compatibility of data processing at the edge MCM.
+  // User has to check that this is in the chamber if it is essential.
+  // Return -100 if iadc is invalid.
+  //
   // Caution: ADC ordering in the online data is opposite to the pad column ordering.
   // And it is not one-by-one correspondence. Precise drawing can be found in:
   // http://wiki.kip.uni-heidelberg.de/ti/TRD/index.php/Image:ROB_MCM_numbering.pdf
 
-  if (iadc < 0 || iadc > 19 ) return -1;
+  if (iadc < 0 || iadc > 19 ) return -100;
   Int_t mcmcol = imcm%fgkNmcmRobInCol + GetRobSide(irob)*fgkNmcmRobInCol;  // MCM column number on ROC [0..7]
   Int_t padcol = mcmcol*fgkNcolMcm + fgkNcolMcm + 1 - iadc;
-  if( padcol < 0 || padcol >= fgkNcol ) return -1;
+  // if( padcol < 0 || padcol >= fgkNcol ) return -1;   // thisi s commented because of reson above KO
   return padcol;
 }
 
@@ -238,3 +259,42 @@ Int_t AliTRDfeeParam::GetColSide(Int_t icol) const
   //c2            = fC2;
   //ped           = fPedestal;
 //};
+
+
+//_____________________________________________________________________________
+Int_t    AliTRDfeeParam::GetRAWversion()
+{
+  // Return raw data version (major number only)
+
+  return fRAWversion;
+}
+
+//_____________________________________________________________________________
+void     AliTRDfeeParam::SetRAWversion( Int_t rawver )
+{
+  // Set raw data version (major number only)
+  // Maximum available number is preset in fgkMaxRAWversion
+
+  if( rawver >= 0 && rawver <= fgkMaxRAWversion ) {
+
+    fRAWversion = rawver ;
+  } else {
+    AliError(Form("Raw version is out of range: %d",rawver));
+  }
+}
+
+//_____________________________________________________________________________
+Bool_t   AliTRDfeeParam::GetRAWstoreRaw()
+{
+  // Returns kTRUE if raw data itself is read instead of filtered data
+
+  return fRAWstoreRaw;
+}
+
+//_____________________________________________________________________________
+void     AliTRDfeeParam::SetRAWstoreRaw( Bool_t storeraw )
+{
+  // If kTRUE is set, raw data itself is read instead of filtered data
+
+  fRAWstoreRaw = storeraw;
+}
index 92c116e..c43c249 100644 (file)
@@ -48,14 +48,14 @@ class AliTRDfeeParam : public TObject
   static  Int_t    GetNrobC0()            { return fgkNrobC0; }
   static  Int_t    GetNrobC1()            { return fgkNrobC1; }
   static  Int_t    GetNadcMcm()           { return fgkNadcMcm; }
-  static  Int_t    GetNtimebin()          { return fgkNtimebin; }
+  // static  Int_t    GetNtimebin()       { return fgkNtimebin; }
   static  Int_t    GetNcol()              { return fgkNcol; }
   static  Int_t    GetNcolMcm()           { return fgkNcolMcm; }
   static  Int_t    GetNrowC0()            { return fgkNrowC0; }
   static  Int_t    GetNrowC1()            { return fgkNrowC1; }
 
-  static  Int_t    GetADCpedestal()       { return fgkADCpedestal; }
-  static  Int_t    GetADCnoise()          { return fgkADCnoise; }
+  // static  Int_t    GetADCpedestal()    { return fgkADCpedestal; }
+  // static  Int_t    GetADCnoise()       { return fgkADCnoise; }
   static  Int_t    GetADCDAC()            { return fgkADCDAC; }
 
   static  Bool_t   isPFon()               { return fgkPFon; }
@@ -65,7 +65,7 @@ class AliTRDfeeParam : public TObject
   static  Int_t    GetPFtimeConstant()    {  return fgkPFtimeConstant; }
   static  Int_t    GetPFeffectPedestal()  {  return fgkPFeffectPedestal; }
 
-  //          Float_t  GetClusThr()           { return fClusThr; };
+  //        Float_t  GetClusThr()           { return fClusThr; };
   //        Float_t  GetPadThr() const { return fPadThr; };
   //        Int_t    GetTailCancelation() const { return fTCOn; };
   //        Int_t    GetNexponential() const { return fTCnexp; };
@@ -87,8 +87,11 @@ class AliTRDfeeParam : public TObject
   static  Int_t    GetEBindLUT()          { return fgkEBindLUT; }
   static  Int_t    GetEBignoreNeighbour() { return fgkEBignoreNeighbour; }
 
-  static  Int_t    GetRAWversion()        { return fgkRAWversion; }
-  static  Bool_t   GetRAWstoreRaw()       { return fgkRAWstoreRaw; }
+  // Concerning raw data format
+          Int_t    GetRAWversion();
+          void     SetRAWversion( Int_t rawver );
+          Bool_t   GetRAWstoreRaw();
+          void     SetRAWstoreRaw( Bool_t storeraw );
 
  protected:
 
@@ -108,15 +111,15 @@ class AliTRDfeeParam : public TObject
   static const Int_t    fgkNrobC0            = 6;         // Number of ROBs per C0 chamber  (old fgkROBmaxC0)
   static const Int_t    fgkNrobC1            = 8;         // Number of ROBs per C1 chamber  (old fgkROBmaxC1)
   static const Int_t    fgkNadcMcm           = 21;        // Number of ADC channels per MCM (old fgkADCmax)
-  static const Int_t    fgkNtimebin          = 30;        // Number of Time bins            (old fgkTBmax)
+  // static const Int_t    fgkNtimebin       = 24;        // Number of Time bins should come from calibDB
   static const Int_t    fgkNcol              = 144;       // Number of pads per padplane row(old fgkColmax)
   static const Int_t    fgkNcolMcm           = 18;        // Number of pads per MCM         (old fgkPadmax)
   static const Int_t    fgkNrowC0            = 12;        // Number of Rows per C0 chamber  (old fgkRowmaxC0)
   static const Int_t    fgkNrowC1            = 16;        // Number of Rows per C1 chamber  (old fgkRowmaxC1)
 
   // ADC intrinsic parameters
-  static const Int_t    fgkADCpedestal       = 0;         // ADC baseline * 100 (old name fPedestal) it is not PFeffectPedestal
-  static const Int_t    fgkADCnoise          = 10;        // ADC noise    * 100 (not contained in the digitizer) [in ADC] 
+  // static const Int_t    fgkADCpedestal    = 0;         // This is simulation parameter and not the value set in FEE, moved to simParam
+  // static const Int_t    fgkADCnoise       = 10;        // This is simulation parameter and not the value set in FEE, moved to simParam
   static const Int_t    fgkADCDAC            = 0;         // 5 bit ADC gain parameter
 
   // TRAP filter global setup
@@ -125,17 +128,17 @@ class AliTRDfeeParam : public TObject
   static const Bool_t   fgkTFon              = kTRUE;     // Tail cancelation Filter enable/disable flag (old name fTCOn)
 
   // PF setup
-  static const Int_t    fgkPFtimeConstant    =  0;        // 0 for fastest, 3 for slowest (no effect, probably)
-  static const Int_t    fgkPFeffectPedestal  = 10;        // [in ADC units] the desired baseline (Additive)
+  static const Int_t    fgkPFtimeConstant    =  0;    // 0 for fastest, 3 for slowest (no effect, probably)
+  static const Int_t    fgkPFeffectPedestal  = 10;    // [in ADC units] the desired baseline (Additive)
 
   // GF setup
-  static const Int_t    fgkGFnoise           =  0;        // Noise level increased by gain filter x 100 [in ADC] (to be measured)
+  static const Int_t    fgkGFnoise           =  0;    // Noise level increased by gain filter x 100 [in ADC] (to be measured)
 
   // TF setup
-  static const Int_t    fgkTFtype            = 1;    // TC type (0=analog, 1=digital, 2=MI) (old name fFilterType)
+  static const Int_t    fgkTFtype            = 1;     // TC type (0=analog, 1=digital, 2=MI) (old name fFilterType)
 
   // OLD TF setup (calculated from above)  (valid only for fgkTFsimType = 0 or 1)
-  static const Int_t    fgkTFnExp          = 1;    // Number of exponential for simType 0 and 1
+  static const Int_t    fgkTFnExp          = 1;       // Number of exponential for simType 0 and 1
 
   // following need Instance because initialized in constructor
                Float_t  fTFr1;                        // Time constant [us] long (old name fR1)
@@ -151,10 +154,10 @@ class AliTRDfeeParam : public TObject
   static const Int_t    fgkTFattPar2          = 14;   //                      = -alphaL/ln(lambdaL)-(1-alphaL)/ln(lambdaS)
 
   // ZS parameters
-  static const Int_t    fgkEBsglIndThr        = 3;    // EBIS in ADC units
-  static const Int_t    fgkEBsumIndThr        = 4;    // EBIT in ADC units
+  static const Int_t    fgkEBsglIndThr        = 5;    // EBIS in ADC units
+  static const Int_t    fgkEBsumIndThr        = 5;    // EBIT in ADC units
   static const Int_t    fgkEBindLUT           = 0xF0; // EBIL lookup table
-  static const Int_t    fgkEBignoreNeighbour  = 1;    // EBIN 0:include neighbor
+  static const Int_t    fgkEBignoreNeighbour  = 0;    // EBIN 0:include neighbor
 
   // Charge accumulators
   static const Int_t    fgkPREPqAcc0Start      =  0;   // Preprocessor Charge Accumulator 0 Start
@@ -168,8 +171,9 @@ class AliTRDfeeParam : public TObject
   //static const Float_t  fPadThr;                      // Pad threshold
 
   // For raw production
-  static const Int_t    fgkRAWversion          = 2;     // Raw data production version
-  static const Bool_t   fgkRAWstoreRaw         = kTRUE; // Store unfiltered data for raw data stream
+               Int_t    fRAWversion;                    // Raw data production version
+  static const Int_t    fgkMaxRAWversion       = 3;     // Maximum raw version number supported
+               Bool_t   fRAWstoreRaw;                   // Store unfiltered data for raw data stream
 
  private:
 
index becfef1..f5cff78 100644 (file)
@@ -1699,79 +1699,79 @@ Double_t AliTRDgeometry::GetCol0(Int_t p)
 }
 
 //_____________________________________________________________________________
-Int_t AliTRDgeometry::GetPadRowFromMCM(Int_t irob, Int_t imcm) const
-{
+//Int_t AliTRDgeometry::GetPadRowFromMCM(Int_t irob, Int_t imcm) const
+//{
   //
   // Return on which row this mcm sits 
   //
-
-  return fgkMCMrow*(irob/2) + imcm/fgkMCMrow;
-
-}
+//
+//  return fgkMCMrow*(irob/2) + imcm/fgkMCMrow;
+//
+//}
 
 //_____________________________________________________________________________
-Int_t AliTRDgeometry::GetPadColFromADC(Int_t irob, Int_t imcm, Int_t iadc) const
-{
+//Int_t AliTRDgeometry::GetPadColFromADC(Int_t irob, Int_t imcm, Int_t iadc) const
+//{
   //
   // Return which pad is connected to this adc channel. return -1 if it
   // is one of the not directly connected adc channels (0, 1 20)
   //
-
-  if (iadc < 2 || iadc > 19 ) return -1;
-
-  return (iadc-2) + (imcm%fgkMCMrow)*fgkPadmax + GetRobSide(irob)*fgkColmax/2;
-
-}
+//
+//  if (iadc < 2 || iadc > 19 ) return -1;
+//
+//  return (iadc-2) + (imcm%fgkMCMrow)*fgkPadmax + GetRobSide(irob)*fgkColmax/2;
+//
+//}
 
 //_____________________________________________________________________________
-Int_t AliTRDgeometry::GetMCMfromPad(Int_t irow, Int_t icol) const
-{
+//Int_t AliTRDgeometry::GetMCMfromPad(Int_t irow, Int_t icol) const
+//{
   //
   // Return on which mcm this pad is
   //
-
-  if ( irow < 0 || icol < 0 || irow > fgkRowmaxC1 || icol > fgkColmax ) return -1;
-
-  return (icol%(fgkColmax/2))/fgkPadmax + fgkMCMrow*(irow%fgkMCMrow);
-
-}
+//
+//  if ( irow < 0 || icol < 0 || irow > fgkRowmaxC1 || icol > fgkColmax ) return -1;
+//
+//  return (icol%(fgkColmax/2))/fgkPadmax + fgkMCMrow*(irow%fgkMCMrow);
+//
+//}
 
 //_____________________________________________________________________________
-Int_t AliTRDgeometry::GetROBfromPad(Int_t irow, Int_t icol) const
-{
+//Int_t AliTRDgeometry::GetROBfromPad(Int_t irow, Int_t icol) const
+//{
   //
   // Return on which rob this pad is
   //
-
-  return (irow/fgkMCMrow)*2 + GetColSide(icol);
-
-}
+//
+//  return (irow/fgkMCMrow)*2 + GetColSide(icol);
+//
+//}
 
 //_____________________________________________________________________________
-Int_t AliTRDgeometry::GetRobSide(Int_t irob) const
-{
+//Int_t AliTRDgeometry::GetRobSide(Int_t irob) const
+//{
   //
   // Return on which side this rob sits (A side = 0, B side = 1)
   //
-
-  if ( irob < 0 || irob >= fgkROBmaxC1 ) return -1;
-
-  return irob%2;
-
-}
+//
+//  if ( irob < 0 || irob >= fgkROBmaxC1 ) return -1;
+//
+//  return irob%2;
+//
+//}
 
 //_____________________________________________________________________________
-Int_t AliTRDgeometry::GetColSide(Int_t icol) const
-{
+//Int_t AliTRDgeometry::GetColSide(Int_t icol) const
+//{
   //
   // Return on which side this column sits (A side = 0, B side = 1)
   //
-
-  if ( icol < 0 || icol >= fgkColmax ) return -1;
-
-  return icol/(fgkColmax/2);
-
-}
+//
+//  if ( icol < 0 || icol >= fgkColmax ) return -1;
+//
+//  return icol/(fgkColmax/2);
+//
+//}
 
 //_____________________________________________________________________________
 Bool_t AliTRDgeometry::ReadGeoMatrices()
index 0fc1eb8..8b1e571 100644 (file)
@@ -66,13 +66,13 @@ class AliTRDgeometry : public AliGeometry {
           Double_t GetRow0(Int_t p, Int_t c, Int_t /*s*/);
           Double_t GetCol0(Int_t p);
 
-  // Translation from MCM to Pad and vice versa
-  virtual Int_t    GetPadRowFromMCM(Int_t irob, Int_t imcm) const;
-  virtual Int_t    GetPadColFromADC(Int_t irob, Int_t imcm, Int_t iadc) const;
-  virtual Int_t    GetMCMfromPad(Int_t irow, Int_t icol) const;
-  virtual Int_t    GetROBfromPad(Int_t irow, Int_t icol) const;
-  virtual Int_t    GetRobSide(Int_t irob) const;
-  virtual Int_t    GetColSide(Int_t icol) const;
+  // Translation from MCM to Pad and vice versa (these functions are now in feeParam)
+  //virtual Int_t    GetPadRowFromMCM(Int_t irob, Int_t imcm) const;
+  //virtual Int_t    GetPadColFromADC(Int_t irob, Int_t imcm, Int_t iadc) const;
+  //virtual Int_t    GetMCMfromPad(Int_t irow, Int_t icol) const;
+  //virtual Int_t    GetROBfromPad(Int_t irow, Int_t icol) const;
+  //virtual Int_t    GetRobSide(Int_t irob) const;
+  //virtual Int_t    GetColSide(Int_t icol) const;
 
   static Float_t   GetTime0(Int_t p)                                   { return fgkTime0[p];     }
 
index 4c48a53..86f0686 100644 (file)
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
 
-/*
-$Log$
-*/
-
 ///////////////////////////////////////////////////////////////////////////////
 //                                                                           //
 //  TRD MCM (Multi Chip Module) simulator                                    //
 //                                                                           //
 ///////////////////////////////////////////////////////////////////////////////
 
-#include <TMath.h>
+/* $Id$ */
+
+/*
+
+  New release on 2007/08/17
+
+AliTRDmcmSim is now stably working and zero suppression function seems ok.
+From now, the default version of raw data is set to 3 in AliTRDfeeParam.
+
+The following internal parameters were abolished because it is useless and
+made trouble:
+
+   fColOfADCbeg
+   fColOfADCend
+
+GetCol member was modified accordingly. 
+
+New member function DumpData was prepared for diagnostics.
+
+ZSMapping member function was debugged. It was causing crash due to
+wrong indexing in 1 dimensional numbering. Also code was shaped up better.
+
+*/
+
+/*Semi-final version of TRD raw data simulation code with zero suppression (ZS)
+similar to TRD FEE. ZS is realized by the class group:
+
+  AliTRDfeeParam
+  AliTRDmcmSim
+  AliTRDrawData
+
+AliTRDfeeParam has been modified to have more parameters like raw data
+production version and so on. AliTRDmcmSim is new class and this is the core
+of MCM (PASA+TRAP) simulator. It has still very simple function and it will be
+another project to improve this to make it closer to the reall FEE.
+AliTRDrawData has been modified to use new class AliTRDmcmSim.
 
+These modifications were tested on Aug. 02 HEAD version that code itself
+compiles. I'm sure there must be still bugs and we need testing by as many as
+possible persons now. Especially it seems HLT part is impacted by problems
+because some parameters were moved from AliTRDrawData to AliTRDfeeParam (like
+fRawVersion disappeared from AliTRDrawData).
+
+In TRD definition, we have now 4 raw data versions.
+
+  0 very old offline version (by Bogdan)
+  1 test version (no zero suppression)
+  2 final version (no zero suppression)
+  3 test version (with zero suppression)
+
+The default is still set to 2 in AliTRDfeeParam::fgkRAWversion and it uses
+previously existing codes. If you set this to 3, AliTRDrawData changes behavior
+to use AliTRDmcmSim with ZS.
+
+Plan is after we make sure it works stably, we delete AliTRDmcm which is obsolete.
+However it still take time because tarcklet part is not yet touched.
+The default raw version is 2.
+
+                                                                 Ken Oyama
+*/
+
+#include <fstream>
+#include <TMath.h>
 #include "AliLog.h"
 #include "AliTRDmcmSim.h"
 #include "AliTRDfeeParam.h"
+#include "AliTRDSimParam.h"
 #include "AliTRDgeometry.h"
+#include "AliTRDcalibDB.h"
 
 ClassImp(AliTRDmcmSim)
 
@@ -36,6 +95,8 @@ ClassImp(AliTRDmcmSim)
 AliTRDmcmSim::AliTRDmcmSim() :TObject()
   ,fInitialized(kFALSE)
   ,fFeeParam(NULL)
+  ,fSimParam(NULL)
+  ,fCal(NULL)
   ,fGeo(NULL)
   ,fChaId(-1)
   ,fSector(-1)
@@ -46,8 +107,6 @@ AliTRDmcmSim::AliTRDmcmSim() :TObject()
   ,fNADC(-1)
   ,fNTimeBin(-1)
   ,fRow(-1)
-  ,fColOfADCbeg(-1)
-  ,fColOfADCend(-1)
   ,fADCR(NULL)
   ,fADCF(NULL)
   ,fZSM(NULL)
@@ -88,6 +147,8 @@ void AliTRDmcmSim::Init( Int_t cha_id, Int_t rob_pos, Int_t mcm_pos )
   // fADC array will be reused with filled by zero
 
   fFeeParam      = AliTRDfeeParam::Instance();
+  fSimParam      = AliTRDSimParam::Instance();
+  fCal           = AliTRDcalibDB::Instance();
   fGeo           = new AliTRDgeometry();
   fChaId         = cha_id;
   fSector        = fGeo->GetSector( fChaId );
@@ -96,10 +157,8 @@ void AliTRDmcmSim::Init( Int_t cha_id, Int_t rob_pos, Int_t mcm_pos )
   fRobPos        = rob_pos;
   fMcmPos        = mcm_pos;
   fNADC          = fFeeParam->GetNadcMcm();
-  fNTimeBin      = fFeeParam->GetNtimebin();
+  fNTimeBin      = fCal->GetNumberOfTimeBins();
   fRow           = fFeeParam->GetPadRowFromMCM( fRobPos, fMcmPos );
-  fColOfADCbeg   = fFeeParam->GetPadColFromADC( fRobPos, fMcmPos, 0 );
-  fColOfADCend   = fFeeParam->GetPadColFromADC( fRobPos, fMcmPos, fNADC-1 );
 
   // Allocate ADC data memory if not yet done
   if( fADCR == NULL ) {
@@ -123,19 +182,25 @@ void AliTRDmcmSim::Init( Int_t cha_id, Int_t rob_pos, Int_t mcm_pos )
     }
     fZSM1Dim[iadc] = 1;      // Default unread = 1
   }
-
+  
   fInitialized = kTRUE;
 }
 
 //_____________________________________________________________________________
+Bool_t AliTRDmcmSim::CheckInitialized()
+{
+  if( ! fInitialized ) {
+    AliDebug(2, Form ("AliTRDmcmSim is not initialized but function other than Init() is called."));
+  }
+  return fInitialized;
+}
+
+//_____________________________________________________________________________
 void AliTRDmcmSim::SetData( Int_t iadc, Int_t *adc )
 {
   // Store ADC data into array of raw data
 
-  if( ! fInitialized ) {
-    //Log (Form ("Error: AliTRDmcmSim is not initialized but setData is called."));
-    return;
-  }
+  if( !CheckInitialized() ) return;
 
   if( iadc < 0 || iadc >= fNADC ) {
     //Log (Form ("Error: iadc is out of range (should be 0 to %d).", fNADC-1));
@@ -152,10 +217,7 @@ void AliTRDmcmSim::SetData( Int_t iadc, Int_t it, Int_t adc )
 {
   // Store ADC data into array of raw data
 
-  if( ! fInitialized ) {
-    //Log (Form ("Error: AliTRDmcmSim is not initialized but setData is called."));
-    return;
-  }
+  if( !CheckInitialized() ) return;
 
   if( iadc < 0 || iadc >= fNADC ) {
     //Log (Form ("Error: iadc is out of range (should be 0 to %d).", fNADC-1));
@@ -170,10 +232,7 @@ void AliTRDmcmSim::SetDataPedestal( Int_t iadc )
 {
   // Store ADC data into array of raw data
 
-  if( ! fInitialized ) {
-    //Log (Form ("Error: AliTRDmcmSim is not initialized but setData is called."));
-    return;
-  }
+  if( !CheckInitialized() ) return;
 
   if( iadc < 0 || iadc >= fNADC ) {
     //Log (Form ("Error: iadc is out of range (should be 0 to %d).", fNADC-1));
@@ -181,7 +240,7 @@ void AliTRDmcmSim::SetDataPedestal( Int_t iadc )
   }
 
   for( Int_t it = 0 ; it < fNTimeBin ; it++ ) {
-    fADCR[iadc][it] = fFeeParam->GetADCpedestal();
+    fADCR[iadc][it] = fSimParam->GetADCbaseline();
   }
 }
 
@@ -189,8 +248,9 @@ void AliTRDmcmSim::SetDataPedestal( Int_t iadc )
 Int_t AliTRDmcmSim::GetCol( Int_t iadc )
 {
   // Return column id of the pad for the given ADC channel
+  if( !CheckInitialized() ) return -1;
 
-  return (fColOfADCbeg - iadc);
+  return fFeeParam->GetPadColFromADC(fRobPos, fMcmPos, iadc);
 }
 
 
@@ -209,6 +269,8 @@ Int_t AliTRDmcmSim::ProduceRawStream( UInt_t *buf, Int_t maxSize )
   Int_t   rawVer   = fFeeParam->GetRAWversion();
   Int_t **adc;
 
+  if( !CheckInitialized() ) return 0;
+
   if( fFeeParam->GetRAWstoreRaw() ) {
     adc = fADCR;
   } else {
@@ -246,19 +308,19 @@ Int_t AliTRDmcmSim::ProduceRawStream( UInt_t *buf, Int_t maxSize )
   UInt_t aa=0, a1=0, a2=0, a3=0;
 
   for (Int_t iAdc = 0; iAdc < 21; iAdc++ ) {
-    if( rawVer>= 3 && fZSM1Dim[iAdc] == 1 ) continue; // suppressed
+    if( rawVer>= 3 && fZSM1Dim[iAdc] != 0 ) continue; // suppressed
     aa = !(iAdc & 1) + 2;
     for (Int_t iT = 0; iT < fNTimeBin; iT+=3 ) {
       a1 = ((iT    ) < fNTimeBin ) ? adc[iAdc][iT  ] : 0;
       a2 = ((iT + 1) < fNTimeBin ) ? adc[iAdc][iT+1] : 0;
       a3 = ((iT + 2) < fNTimeBin ) ? adc[iAdc][iT+2] : 0;
-    }
-    x = (a3 << 22) | (a2 << 12) | (a1 << 2) | aa;
-    if (nw < maxSize) {
-      buf[nw++] = x;
-    }
-    else {
-      of++;
+      x = (a3 << 22) | (a2 << 12) | (a1 << 2) | aa;
+      if (nw < maxSize) {
+       buf[nw++] = x;
+      }
+      else {
+       of++;
+      }
     }
   }
 
@@ -271,10 +333,7 @@ void AliTRDmcmSim::Filter()
 {
   // Apply digital filter
 
-  if( ! fInitialized ) {
-    // Log (Form ("Error: AliTRDmcmSim is not initialized but setData is called."));
-    return;
-  }
+  if( !CheckInitialized() ) return;
 
   // Initialize filtered data array with raw data
   for( Int_t iadc = 0 ; iadc < fNADC; iadc++ ) {
@@ -294,7 +353,7 @@ void AliTRDmcmSim::FilterPedestal()
 {
   // Apply pedestal filter
 
-  Int_t ap = fFeeParam->GetADCpedestal();      // ADC instrinsic pedestal
+  Int_t ap = fSimParam->GetADCbaseline();      // ADC instrinsic pedestal
   Int_t ep = fFeeParam->GetPFeffectPedestal(); // effective pedestal
   Int_t tc = fFeeParam->GetPFtimeConstant();   // this makes no sense yet
 
@@ -309,6 +368,8 @@ void AliTRDmcmSim::FilterPedestal()
 void AliTRDmcmSim::FilterGain()
 {
   // Apply gain filter (not implemented)
+  // Later it will be implemented because gain digital filiter will
+  // increase noise level.
 }
 
 //_____________________________________________________________________________
@@ -371,17 +432,25 @@ void AliTRDmcmSim::ZSMapping()
   Int_t EBIT = fFeeParam->GetEBsumIndThr();       // TRAP default = 0x28 (Tit=40)
   Int_t EBIL = fFeeParam->GetEBindLUT();          // TRAP default = 0xf0 (lookup table accept (I2,I1,I0)=(111) or (110) or (101) or (100))
   Int_t EBIN = fFeeParam->GetEBignoreNeighbour(); // TRAP default = 1 (no neighbor sensitivity)
+  Int_t ep   = AliTRDfeeParam::GetPFeffectPedestal();
+
+  if( !CheckInitialized() ) return;
 
   for( Int_t iadc = 1 ; iadc < fNADC-1; iadc++ ) {
     for( Int_t it = 0 ; it < fNTimeBin ; it++ ) {
 
+      // Get ADC data currently in filter buffer
+      Int_t Ap = fADCF[iadc-1][it] - ep; // previous
+      Int_t Ac = fADCF[iadc  ][it] - ep; // current
+      Int_t An = fADCF[iadc+1][it] - ep; // next
+
       // evaluate three conditions
-      Int_t I0 = ( fADCF[iadc][it] >=  fADCF[iadc-1][it] && fADCF[iadc][it] >=  fADCF[iadc+1][it] ) ? 0 : 1; // peak center detection
-      Int_t I1 = ( (fADCF[iadc-1][it] + fADCF[iadc][it] + fADCF[iadc+1][it]) > EBIT )               ? 0 : 1; // cluster
-      Int_t I2 = ( fADCF[iadc][it] > EBIS )                                                         ? 0 : 1; // absolute large peak
+      Int_t I0 = ( Ac >=  Ap && Ac >=  An ) ? 0 : 1; // peak center detection
+      Int_t I1 = ( Ap + Ac + An > EBIT )    ? 0 : 1; // cluster
+      Int_t I2 = ( Ac > EBIS )              ? 0 : 1; // absolute large peak
 
-      Int_t I = I2 * 4 + I1 * 2 + I0; // Bit position in lookup table
-      Int_t D = (EBIL >> I) & 1;      // Looking up  (here D=0 means true and D=1 means false according to TRAP manual)
+      Int_t I = I2 * 4 + I1 * 2 + I0;    // Bit position in lookup table
+      Int_t D = (EBIL >> I) & 1;         // Looking up  (here D=0 means true and D=1 means false according to TRAP manual)
 
       fZSM[iadc][it] &= D;
       if( EBIN == 0 ) {  // turn on neighboring ADCs
@@ -394,7 +463,73 @@ void AliTRDmcmSim::ZSMapping()
   // do 1 dim projection
   for( Int_t iadc = 0 ; iadc < fNADC; iadc++ ) {
     for( Int_t it = 0 ; it < fNTimeBin ; it++ ) {
-      fZSM1Dim[iadc] &= fZSM[iadc+1][it];
+      fZSM1Dim[iadc] &= fZSM[iadc][it];
+    }
+  }
+}
+
+//_____________________________________________________________________________
+void AliTRDmcmSim::DumpData( char *f, char *target )
+{
+  // Dump data stored (for debugging).
+  // target should contain one or multiple of the following characters
+  //   R   for raw data
+  //   F   for filtered data
+  //   Z   for zero suppression map
+  //   S   Raw dat astream
+  // other characters are simply ignored
+  UInt_t tempbuf[1024];
+
+  if( !CheckInitialized() ) return;
+
+  std::ofstream of( f, std::ios::out | std::ios::app );
+  of << Form("AliTRDmcmSim::DumpData det=%03d sm=%02d stack=%d layer=%d rob=%d mcm=%02d\n",
+            fChaId, fSector, fStack, fLayer, fRobPos, fMcmPos );
+
+  for( int t=0 ; target[t] != 0 ; t++ ) {
+    switch( target[t] ) {
+    case 'R' :
+    case 'r' :
+      of << Form("fADCR (raw ADC data)\n");
+      for( Int_t iadc = 0 ; iadc < fNADC; iadc++ ) {
+       of << Form("  ADC %02d: ", iadc);
+       for( Int_t it = 0 ; it < fNTimeBin ; it++ ) {
+         of << Form("% 4d",  fADCR[iadc][it]);
+       }
+       of << Form("\n");
+      }
+      break;
+    case 'F' :
+    case 'f' :
+      of << Form("fADCF (filtered ADC data)\n");
+      for( Int_t iadc = 0 ; iadc < fNADC; iadc++ ) {
+       of << Form("  ADC %02d: ", iadc);
+       for( Int_t it = 0 ; it < fNTimeBin ; it++ ) {
+         of << Form("% 4d",  fADCF[iadc][it]);
+       }
+       of << Form("\n");
+      }
+      break;
+    case 'Z' :
+    case 'z' :
+      of << Form("fZSM and fZSM1Dim (Zero Suppression Map)\n");
+      for( Int_t iadc = 0 ; iadc < fNADC; iadc++ ) {
+       of << Form("  ADC %02d: ", iadc);
+       if( fZSM1Dim[iadc] == 0 ) { of << " R   " ; } else { of << " .   "; } // R:read .:suppressed
+       for( Int_t it = 0 ; it < fNTimeBin ; it++ ) {
+         if( fZSM[iadc][it] == 0 ) { of << " R"; } else { of << " ."; } // R:read .:suppressed
+       }
+       of << Form("\n");
+      }
+      break;
+    case 'S' :
+    case 's' :
+      Int_t s = ProduceRawStream( tempbuf, 1024 ); 
+      of << Form("Stream for Raw Simulation size=%d rawver=%d\n", s, fFeeParam->GetRAWversion());
+      of << Form("  address  data\n");
+      for( int i = 0 ; i < s ; i++ ) {
+       of << Form("  %04x     %08x\n", i, tempbuf[i]);
+      }
     }
   }
 }
@@ -460,18 +595,12 @@ void AliTRDmcmSim::FilterSimDeConvExpD(Int_t *source, Int_t *target, Int_t n, In
   // source will not be changed
   //
 
-  Int_t i = 0;
-
+  Int_t i        = 0;
   Int_t fAlphaL  = 0;
   Int_t fAlphaS  = 0;
-  Int_t fLambdaL = 0;
-  Int_t fLambdaS = 0;
   Int_t fTailPed = 0;
-
   Int_t iAlphaL  = 0;
   Int_t iAlphaS  = 0;
-  Int_t iLambdaL = 0;
-  Int_t iLambdaS = 0;
 
   // FilterOpt.C (aliroot@pel:/homel/aliroot/root/work/beamt/CERN02)
   // initialize (coefficient = alpha, rates = lambda)
@@ -482,10 +611,10 @@ void AliTRDmcmSim::FilterSimDeConvExpD(Int_t *source, Int_t *target, Int_t n, In
   Double_t c1 = (Double_t)fFeeParam->GetTFc1();
   Double_t c2 = (Double_t)fFeeParam->GetTFc2();
 
-  fLambdaL = (Int_t)((TMath::Exp(-dt/r1) - 0.75) * 2048.0);
-  fLambdaS = (Int_t)((TMath::Exp(-dt/r2) - 0.25) * 2048.0);
-  iLambdaL = fLambdaL & 0x01FF; iLambdaL |= 0x0600;    //  9 bit paramter + fixed bits
-  iLambdaS = fLambdaS & 0x01FF; iLambdaS |= 0x0200;    //  9 bit paramter + fixed bits
+  Int_t fLambdaL = (Int_t)((TMath::Exp(-dt/r1) - 0.75) * 2048.0);
+  Int_t fLambdaS = (Int_t)((TMath::Exp(-dt/r2) - 0.25) * 2048.0);
+  Int_t iLambdaL = fLambdaL & 0x01FF; iLambdaL |= 0x0600; //  9 bit paramter + fixed bits
+  Int_t iLambdaS = fLambdaS & 0x01FF; iLambdaS |= 0x0200; //  9 bit paramter + fixed bits
 
   if (nexp == 1) {
     fAlphaL = (Int_t) (c1 * 2048.0);
@@ -527,8 +656,8 @@ void AliTRDmcmSim::FilterSimDeConvExpD(Int_t *source, Int_t *target, Int_t n, In
 
   for (i = 0; i < n; i++) {
 
-    result = (source[i] - correction);
-    if (result < 0) {                          
+    result = (source[i]  - correction);
+    if (result < 0) { // Too much undershoot
       result = 0;
     }
 
index 0f4690d..44fd4b3 100644 (file)
 #include <TObject.h>
 
 class AliTRDfeeParam;
+class AliTRDSimParam;
+class AliTRDcalibDB;
 class AliTRDgeometry;
 
 class AliTRDmcmSim : public TObject {
 
  public:
 
-  AliTRDmcmSim();
-  virtual         ~AliTRDmcmSim();
+                    AliTRDmcmSim();
+  virtual          ~AliTRDmcmSim();
 
   //PH  virtual void      Copy(TObject &m) const;
 
-          void      Init( Int_t cha_id, Int_t rob_pos, Int_t mcm_pos ); // Initialize MCM by the position parameters
+          void      Init( Int_t cha, Int_t rob, Int_t mcm );   // Initialize MCM by the position parameters
           void      SetData(Int_t iadc, Int_t *adc);           // Set ADC data with array 
-          void      SetData(Int_t iadc, Int_t it, Int_t adc ); // Set ADC data one by one
+          void      SetData(Int_t iadc, Int_t it, Int_t adc ); // Set ADC data
           void      SetDataPedestal(Int_t iadc );              // Fill ADC data with pedestal values
 
-          Int_t     GetChaId()  { return fChaId;  };    // Returns Chamber ID (0-539)
-          Int_t     GetRobPos() { return fRobPos; };    // Returns ROB position (0-7)
-          Int_t     GetMcmPos() { return fMcmPos; };    // Returns MCM position (0-17) (16,17 are mergers)
-          Int_t     GetRow()    { return fRow; };       // Returns Row number on chamber where it is sitting
-         Int_t     GetCol( Int_t iadc );               // Get corresponding column (0-143) from adc ID (= 0-20) 
-                    // for the ADC/Col mapping, see: http://wiki.kip.uni-heidelberg.de/ti/TRD/index.php/Image:ROB_MCM_numbering.pdf
+          Int_t     GetChaId()  { return fChaId;  };           // Returns Chamber ID (0-539)
+          Int_t     GetRobPos() { return fRobPos; };           // Returns ROB position (0-7)
+          Int_t     GetMcmPos() { return fMcmPos; };           // Returns MCM position (0-17) (16,17 are mergers)
+          Int_t     GetRow()    { return fRow; };              // Returns Row number on chamber where the MCM is sitting
+         Int_t     GetCol( Int_t iadc );                      // Get corresponding column (0-143) from for ADC channel iadc = [0:20]
+         // for the ADC/Col mapping, see: http://wiki.kip.uni-heidelberg.de/ti/TRD/index.php/Image:ROB_MCM_numbering.pdf
 
-         Int_t     ProduceRawStream( UInt_t *buf, Int_t bufsize );    // Produce raw data stream from this MCM
-         void      Filter();                           //  Apply digital filters
-         void      ZSMapping();                        //  Do ZS mapping
+         Int_t     ProduceRawStream( UInt_t *buf, Int_t bufsize ); // Produce raw data stream from this MCM
+         void      Filter();                                  // Apply digital filters for existing data
+         void      ZSMapping();                               // Do ZS mapping for existing data
+         void      DumpData( char *f, char *target );         // Dump data stored (only for debugging)
 
  protected:
 
-          Bool_t    fInitialized;                       // Status
-
-         AliTRDfeeParam *fFeeParam;
-         AliTRDgeometry *fGeo;
-
+          Bool_t    fInitialized;                       // Status whether the class is initialized or not
          Int_t     fChaId;                             // Chamber ID
          Int_t     fSector;                            // Sector number of the supermodule
          Int_t     fStack;                             // Chamber stack ID
          Int_t     fLayer;                             // Chamber layer ID
-          Int_t     fRobPos;                            // ROB Position
-          Int_t     fMcmPos;                            // MCM Position
+          Int_t     fRobPos;                            // ROB Position on chamber
+          Int_t     fMcmPos;                            // MCM Position on chamber
          Int_t     fNADC;                              // Number of ADC (usually 21)
-         Int_t     fNTimeBin;                          // Number of Timebin (valiable)
-          Int_t     fRow;                               // Pad row number (0-11 or 0-15)
-          Int_t     fColOfADCbeg;                       // Column corresponds to ADC channel 0
-          Int_t     fColOfADCend;                       // Column corresponds to ADC channel [fNADC-1] (usually 20)
+         Int_t     fNTimeBin;                          // Number of Timebins (variable)
+          Int_t     fRow;                               // Pad row number (0-11 or 0-15) of the MCM on chamber
           Int_t   **fADCR;                              // Array with MCM ADC values (Raw)
           Int_t   **fADCF;                              // Array with MCM ADC values (Filtered)
-          Int_t   **fZSM;                               // Zero Suppression Map
-          Int_t    *fZSM1Dim;                           // Zero Suppression (1 dimensional projection)
+          Int_t   **fZSM;                               // Zero suppression map
+          Int_t    *fZSM1Dim;                           // Zero suppression map (1 dimensional projection)
+
+         // parameter classes
+         AliTRDfeeParam *fFeeParam;
+         AliTRDSimParam *fSimParam;
+         AliTRDcalibDB  *fCal;
+         AliTRDgeometry *fGeo;
 
+         Bool_t    CheckInitialized();                 // Check whether the class is initialized
          void      FilterPedestal();                   // Apply pedestal filter
          void      FilterGain();                       // Apply gain filter
          void      FilterTail();                       // Apply tail filter
 
+         // Here are the several sub functions used only in FilterTail
          void      FilterSimDeConvExpA(Int_t *source, Double_t *target, Int_t n, Int_t nexp);
          void      FilterSimDeConvExpD(Int_t *source, Int_t *target, Int_t n, Int_t nexp);
          void      FilterSimDeConvExpMI(Int_t *source, Double_t *target, Int_t n);
index aed37f9..b2cb041 100644 (file)
@@ -23,6 +23,7 @@
 
 #include <Riostream.h>
 #include <TMath.h>
+#include "TClass.h"
 
 #include "AliDAQ.h"
 #include "AliRawDataHeader.h"
@@ -34,6 +35,7 @@
 #include "AliTRDgeometry.h"
 #include "AliTRDdataArrayI.h"
 #include "AliTRDRawStream.h"
+#include "AliTRDRawStreamV2.h"
 
 #include "AliTRDcalibDB.h"
 #include "AliFstream.h"
@@ -292,7 +294,7 @@ Int_t AliTRDrawData::ProduceHcDataV1andV2(AliTRDdataArrayI *digits, Int_t side
   else if ( rv == 2 ) {
     // h[0] (there are 3 HC header)
     Int_t minorv = 0;      // The minor version number
-    Int_t add    = 1;      // The number of additional header words to follow
+    Int_t add    = 2;      // The number of additional header words to follow
     x = (1<<31) | (rv<<24) | (minorv<<17) | (add<<14) | (sect<<9) | (plan<<6) | (cham<<3) | (side<<2) | 1;
     if (nw < maxSize) {
       buf[nw++] = x; 
@@ -346,7 +348,7 @@ Int_t AliTRDrawData::ProduceHcDataV1andV2(AliTRDdataArrayI *digits, Int_t side
 
       // ADC data
       for (Int_t iAdc = 0; iAdc < 21; iAdc++ ) {
-       Int_t padcol = fGeo->GetPadColFromADC(iRob, iMcm, iAdc);
+       Int_t padcol = fFee->GetPadColFromADC(iRob, iMcm, iAdc);
        UInt_t aa = !(iAdc & 1) + 2;
         UInt_t *a = new UInt_t[nTBin+2];
         // 3 timebins are packed into one 32 bits word
@@ -451,7 +453,7 @@ Int_t AliTRDrawData::ProduceHcDataV3(AliTRDdataArrayI *digits, Int_t side
   // Half Chamber header
   // h[0] (there are 3 HC header)
   Int_t minorv = 0;    // The minor version number
-  Int_t add    = 1;    // The number of additional header words to follow
+  Int_t add    = 2;    // The number of additional header words to follow
   x = (1<<31) | (rv<<24) | (minorv<<17) | (add<<14) | (sect<<9) | (plan<<6) | (cham<<3) | (side<<2) | 1;
   if (nw < maxSize) {
     buf[nw++] = x; 
@@ -511,6 +513,7 @@ Int_t AliTRDrawData::ProduceHcDataV3(AliTRDdataArrayI *digits, Int_t side
       // Simulate process in MCM
       mcm->Filter();     // Apply filter
       mcm->ZSMapping();  // Calculate zero suppression mapping
+      //mcm->DumpData( "trdmcmdata.txt", "RFZS" ); // debugging purpose
 
       // Write MCM data to buffer
       Int_t temp_nw =  mcm->ProduceRawStream( &buf[nw], maxSize - nw );
@@ -532,7 +535,7 @@ Int_t AliTRDrawData::ProduceHcDataV3(AliTRDdataArrayI *digits, Int_t side
     of++;
   }
   if (of != 0) {
-    AliWarning("Buffer overflow. Data is truncated. Please increase buffer size and recompile.");
+    AliError("Buffer overflow. Data is truncated. Please increase buffer size and recompile.");
   }
 
   return nw;
@@ -556,21 +559,22 @@ AliTRDdigitsManager *AliTRDrawData::Raw2Digits(AliRawReader *rawReader)
   AliTRDdigitsManager* digitsManager = new AliTRDdigitsManager();
   digitsManager->CreateArrays();
 
-  AliTRDRawStream input(rawReader);
+  //AliTRDRawStream input(rawReader);
+  AliTRDRawStreamV2 input(rawReader);
   input.SetRawVersion( fFee->GetRAWversion() );
   input.Init();
 
+  AliInfo(Form("Stream version: %s", input.IsA()->GetName()));
+
   // Loop through the digits
   Int_t lastdet = -1;
   Int_t det    = 0;
   Int_t it = 0;
-  while (input.Next()) 
-    {
+  while (input.Next()) {
 
       det    = input.GetDet();
 
-      if (det != lastdet) 
-       {       
+      if (det != lastdet) { // If new detector found
        
          lastdet = det;
 
@@ -603,6 +607,7 @@ AliTRDdigitsManager *AliTRDrawData::Raw2Digits(AliRawReader *rawReader)
            indexes->Allocate(input.GetMaxRow(), input.GetMaxCol(), input.GetNumberOfTimeBins());
        }
     
+      // 3 timebin data are stored per word
       for (it = 0; it < 3; it++)
        {
          if ( input.GetTimeBin() + it < input.GetNumberOfTimeBins() )
index 9680688..5eb48ce 100644 (file)
@@ -29,6 +29,7 @@
 
 #pragma link C++ class  AliTRDrawData+;
 #pragma link C++ class  AliTRDRawStream+;
+#pragma link C++ class  AliTRDRawStreamV2+;
 
 #pragma link C++ class  AliTRDCommonParam+;
 #pragma link C++ class  AliTRDfeeParam+;
index 5c4293b..5b6ab29 100644 (file)
@@ -13,6 +13,7 @@ SRCS= AliTRDarrayI.cxx \
       AliTRDrawData.cxx \
       AliTRDpadPlane.cxx \
       AliTRDRawStream.cxx \
+      AliTRDRawStreamV2.cxx \
       AliTRDCommonParam.cxx \
       AliTRDfeeParam.cxx \
       AliTRDcalibDB.cxx \