Added functionality to the digitreaders(to get the trailerwords and trailer data)
authorkaamodt <kaamodt@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 29 Sep 2008 10:09:35 +0000 (10:09 +0000)
committerkaamodt <kaamodt@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 29 Sep 2008 10:09:35 +0000 (10:09 +0000)
Fixed some bugs in the AliHLTTPCZeroSuppressionComponent
Added a macro to test the active pad selection

HLT/TPCLib/AliHLTTPCDigitReader.cxx
HLT/TPCLib/AliHLTTPCDigitReader.h
HLT/TPCLib/AliHLTTPCDigitReaderDecoder.cxx
HLT/TPCLib/AliHLTTPCDigitReaderDecoder.h
HLT/TPCLib/AliHLTTPCZeroSuppressionComponent.cxx
HLT/TPCLib/macros/activePadsTest.C [new file with mode: 0644]

index 23beeaa..6e6538a 100644 (file)
@@ -198,6 +198,21 @@ AliHLTUInt32_t AliHLTTPCDigitReader::GetAltroBlockHWaddr(Int_t /*row*/, Int_t /*
   return 0;
 }
 
+int AliHLTTPCDigitReader::GetRCUTrailerSize()
+{
+  // see header file for class documentation
+  PrintMissingFastAccessWarning();
+  return 0;
+}
+
+bool AliHLTTPCDigitReader::GetRCUTrailerData(UChar_t *trData)
+{
+  // see header file for class documentation
+  PrintMissingFastAccessWarning();
+  return 0;
+}
+
+
 void AliHLTTPCDigitReader::PrintMissingFastAccessWarning()
 {
   // see header file for class documentation
@@ -207,3 +222,4 @@ void AliHLTTPCDigitReader::PrintMissingFastAccessWarning()
             "      !!! This digit reader does not implement the methods for       !!!\n"
             "      !!! fast data access on channel/bunch basis. Data is discarded !!!");
 }
+
index d450cd9..898a70d 100644 (file)
@@ -193,6 +193,18 @@ public:
    */  
   virtual int GetRowOffset() const;
 
+   /**
+   * Returns the trailer size. used by zerosuppression component. 
+   */
+  virtual int GetRCUTrailerSize();
+
+  /**
+   * Returns the trailer data. used by zerosuppression component. 
+   */
+  virtual bool GetRCUTrailerData(UChar_t *trData);
+
+
+
   /**
    * Access operator to the data of a specific time bin.
    * Not clear if we can manage this.
index 49e92ed..e6acd1e 100644 (file)
@@ -225,6 +225,21 @@ AliHLTUInt32_t AliHLTTPCDigitReaderDecoder::GetAltroBlockHWaddr(Int_t row, Int_t
   }
 }
 
+
+int AliHLTTPCDigitReaderDecoder::GetRCUTrailerSize(){
+  if(fAltroDecoder){
+    return fAltroDecoder->GetRCUTrailerSize();
+  }
+  return 0;
+}
+
+bool AliHLTTPCDigitReaderDecoder::GetRCUTrailerData(UChar_t *trData){
+  if(fAltroDecoder){
+    return fAltroDecoder->GetRCUTrailerData(trData);
+  }
+  return false;
+}
+
 AliAltroDecoder* AliHLTTPCDigitReaderDecoder::GetDecoderInstance()
 {
   // see header file for class documentation
index 7a40a6c..5be613c 100644 (file)
@@ -50,7 +50,9 @@ public:
   int GetRowOffset() const;
   AliHLTUInt32_t GetAltroBlockHWaddr() const;
   AliHLTUInt32_t GetAltroBlockHWaddr(Int_t row, Int_t pad) const;
-  
+  int GetRCUTrailerSize();
+  bool GetRCUTrailerData(UChar_t *trData);  
+
 protected:
   bool NextSignal();
 
index 1a3f169..924071c 100755 (executable)
@@ -276,11 +276,15 @@ int AliHLTTPCZeroSuppressionComponent::DoInit( int argc, const char** argv )
     // -- checking for skipZSdatashipping
     if ( !strcmp( argv[i], "-skip-sending-data" ) ) {
       fSkipSendingZSData = kTRUE;
+      i++;
+      continue;
     }
 
     // -- checking for hw address shipping
     if ( !strcmp( argv[i], "-send-hw-list" ) ) {
       fSendHWList = kTRUE;
+      i++;
+      continue;
     }
       
     Logging(kHLTLogError, "HLT::TPCClusterFinder::DoInit", "Unknown Option", "Unknown option '%s'", argv[i] );
@@ -391,7 +395,6 @@ int AliHLTTPCZeroSuppressionComponent::DoEvent( const AliHLTComponentEventData&
        continue;
       }
 
-      wasInput = 1;
 
       UInt_t slice = AliHLTTPCDefinitions::GetMinSliceNr( *iter );
       UInt_t patch = AliHLTTPCDefinitions::GetMinPatchNr( *iter );
@@ -401,7 +404,12 @@ int AliHLTTPCZeroSuppressionComponent::DoEvent( const AliHLTComponentEventData&
        InitializePadArray();
       }
       
-      fDigitReader->InitBlock(iter->fPtr,iter->fSize,patch,slice);
+      if(fDigitReader->InitBlock(iter->fPtr,iter->fSize,patch,slice)<0){
+       HLTWarning("Decoder failed to initialize, event aborted.");
+       continue;
+      }
+
+      wasInput = 1;
 
       //Here the reading of the data and the zerosuppression takes place
       while(fDigitReader->NextChannel()){//Pad
@@ -414,7 +422,7 @@ int AliHLTTPCZeroSuppressionComponent::DoEvent( const AliHLTComponentEventData&
          continue;
        }
        else if(pad>=fNumberOfPadsInRow[row]||pad<0){
-           continue;
+         continue;
        }  
        
        AliHLTTPCPad *tmpPad = fRowPadVector[row][pad];
@@ -433,102 +441,111 @@ int AliHLTTPCZeroSuppressionComponent::DoEvent( const AliHLTComponentEventData&
          }
        }
        if(tmpPad->GetNAddedSignals()>=(UInt_t)fMinimumNumberOfSignals){
-         fHwAddressList.push_back((AliHLTUInt16_t)fDigitReader->GetAltroBlockHWaddr());
          tmpPad->ZeroSuppress(fNRMSThreshold, fSignalThreshold, fMinimumNumberOfSignals, fStartTimeBin, fEndTimeBin, fLeftTimeBin, fRightTimeBin, fValueBelowAverage);
+         if(tmpPad->GetNAddedSignals()>0){
+           fHwAddressList.push_back((AliHLTUInt16_t)fDigitReader->GetAltroBlockHWaddr());
+         }
        }
       }
-      fDigitReader->Reset();
-    }
-
-  //  HLTDebug("Max number of signals: %d",size/sizeof(Int_t));
 
-  if(wasInput>0){
-  //if(wasInput && fHwAddressList.size()>0){
+      if(wasInput>0){
   
-    AliHLTAltroEncoder altroEncoder;
-    altroEncoder.SetBuffer(outputPtr,size); //tests if one overwrite the buffer is done in the encoder
-
-    // TODO: read the CDH from the data input
-    AliRawDataHeader cdh;
-    altroEncoder.SetCDH((AliHLTUInt8_t*)&cdh,32);
-    for(Int_t row=0;row<fNumberOfRows;row++){
-      for(Int_t pad=0;pad<fNumberOfPadsInRow[row];pad++){
-       AliHLTTPCPad * zeroSuppressedPad= fRowPadVector[row][pad];
-       Int_t currentTime=0;
-       Int_t bunchSize=0;
-       if(zeroSuppressedPad->GetNAddedSignals()>0){
-         while(zeroSuppressedPad->GetNextGoodSignal(currentTime, bunchSize)){
-           for(Int_t i=0;i<bunchSize;i++){
-             altroEncoder.AddSignal(zeroSuppressedPad->GetDataSignal(currentTime+i), currentTime+i);
-           }
+       AliHLTAltroEncoder *altroEncoder = new AliHLTAltroEncoder;
+       altroEncoder->SetBuffer(outputPtr,size); //tests if one overwrite the buffer is done in the encoder
+
+       UChar_t *RCUTrailer=NULL;
+       Int_t RCUTrailerSize=fDigitReader->GetRCUTrailerSize();
+       //      HLTInfo("RCUTrsize %d",RCUTrailerSize );
+       if (RCUTrailerSize<=0 || !fDigitReader->GetRCUTrailerData( RCUTrailer )) {
+         if(RCUTrailer==NULL){
+           HLTWarning("can not find RCU trailer for data block %s 0x%08x: skipping data block",
+                      DataType2Text(iter->fDataType).c_str(), iter->fSpecification);
+           continue;
          }
-         altroEncoder.SetChannel(fDigitReader->GetAltroBlockHWaddr(row, pad));
        }
-      }
-    }
-
-    // TODO: read the RCU trailer from the data input
-    AliHLTUInt8_t dummyTrailer=0;
-    altroEncoder.SetRCUTrailer(&dummyTrailer, sizeof(dummyTrailer));
-    int sizeOfData=altroEncoder.SetLength();
-
-    if (sizeOfData<0) {
-      HLTError("data encoding failed");
-      return sizeOfData;
-    }
-    if(sizeOfData>(int)size){
-      HLTWarning("Buffer too small too add the altrodata: %d of %d byte(s) already used", sizeOfData, size);
-      return -ENOSPC;
-    }
 
+       AliRawDataHeader cdh;
+       altroEncoder->SetCDH((AliHLTUInt8_t*)iter->fPtr,sizeof(AliRawDataHeader));
+       
+       altroEncoder->SetRCUTrailer(RCUTrailer, RCUTrailerSize);
+
+       for(Int_t row=0;row<fNumberOfRows;row++){
+         for(Int_t pad=0;pad<fNumberOfPadsInRow[row];pad++){
+           AliHLTTPCPad * zeroSuppressedPad= fRowPadVector[row][pad];
+           Int_t currentTime=0;
+           Int_t bunchSize=0;
+           if(zeroSuppressedPad->GetNAddedSignals()>0){
+             while(zeroSuppressedPad->GetNextGoodSignal(currentTime, bunchSize)){
+               for(Int_t i=0;i<bunchSize;i++){
+                 cout<<"Data added"<<endl;
+                 altroEncoder->AddSignal((AliHLTUInt16_t)(zeroSuppressedPad->GetDataSignal(currentTime+i)),(AliHLTUInt16_t)(currentTime+i));
+               }
+             }
+             altroEncoder->SetChannel((AliHLTUInt16_t)(fDigitReader->GetAltroBlockHWaddr(row, pad)));
+           }
+         }
+       }
 
-    AliHLTUInt32_t dataOffsetBeforeHW=0;
+       int sizeOfData=altroEncoder->SetLength();
 
+       if (sizeOfData<0) {
+         HLTError("data encoding failed");
+         return sizeOfData;
+       }
+       if(sizeOfData>(int)size){
+         HLTWarning("Buffer too small too add the altrodata: %d of %d byte(s) already used", sizeOfData, size);
+         return -ENOSPC;
+       }
 
-    //Push back the zerosuppressed altro data to the output
-    if(fSkipSendingZSData == kFALSE){
-      AliHLTComponentBlockData bd;
-      FillBlockData( bd );
-      bd.fOffset = 0;
-      bd.fSize = sizeOfData;
-      bd.fDataType = kAliHLTDataTypeDDLRaw;
-      bd.fSpecification = iter->fSpecification;
-      Logging( kHLTLogDebug, "HLT::TPCZeroSuppressionComponent::DoEvent", "Event received", 
-              "Event 0x%08LX (%Lu) output data block %lu of %lu bytes at offset %lu",
-              evtData.fEventID, evtData.fEventID, ndx,size ,0);
-      outputBlocks.push_back( bd );
+       AliHLTUInt32_t dataOffsetBeforeHW=0;
+
+       //Push back the zerosuppressed altro data to the output
+       if(fSkipSendingZSData == kFALSE){
+         AliHLTComponentBlockData bd;
+         FillBlockData( bd );
+         bd.fOffset = 0;
+         bd.fSize = sizeOfData;
+         bd.fDataType = kAliHLTDataTypeDDLRaw|kAliHLTDataOriginTPC;
+         bd.fSpecification = iter->fSpecification;
+         Logging( kHLTLogDebug, "HLT::TPCZeroSuppressionComponent::DoEvent", "Event received", 
+                  "Event 0x%08LX (%Lu) output data block %lu of %lu bytes at offset %lu",
+                  evtData.fEventID, evtData.fEventID, ndx,size ,0);
+         outputBlocks.push_back( bd );
     
-      //Push back the list of hardware addresses to the output
-      dataOffsetBeforeHW=sizeOfData;
-    }
+         //Push back the list of hardware addresses to the output
+         dataOffsetBeforeHW=sizeOfData;
+       }
 
-    AliHLTUInt32_t sizeOfHWArray = 0;
+       AliHLTUInt32_t sizeOfHWArray = 0;
 
-    if(fSendHWList == kTRUE){
-      sizeOfHWArray = fHwAddressList.size()*sizeof(AliHLTUInt16_t);
+       if(fSendHWList == kTRUE){
+         sizeOfHWArray = fHwAddressList.size()*sizeof(AliHLTUInt16_t);
       
-      if(dataOffsetBeforeHW+sizeOfHWArray>size){
-       HLTWarning("Buffer too small too add the active channels: %d of %d byte(s) already used", dataOffsetBeforeHW + sizeOfHWArray, size);
-       return -ENOSPC;
-      }
+         if(dataOffsetBeforeHW+sizeOfHWArray>size){
+           HLTWarning("Buffer too small too add the active channels: %d of %d byte(s) already used", dataOffsetBeforeHW + sizeOfHWArray, size);
+           return -ENOSPC;
+         }
       
-      AliHLTUInt16_t*outputHWPtr=(AliHLTUInt16_t*)(outputPtr+dataOffsetBeforeHW);
-      outputHWPtr = &fHwAddressList[0];
-      AliHLTComponentBlockData bdHW;
-      FillBlockData( bdHW );
-      bdHW.fOffset = dataOffsetBeforeHW;
-      bdHW.fSize = sizeOfHWArray;
-      bdHW.fDataType = kAliHLTDataTypeHwAddr16;
-      bdHW.fSpecification = iter->fSpecification;
-      Logging( kHLTLogDebug, "HLT::TPCZeroSuppressionComponent::DoEvent", "Event received", 
-            "Event 0x%08LX (%Lu) output data block %lu of %lu bytes at offset %lu",
-              evtData.fEventID, evtData.fEventID, ndx,size ,0);
-      outputBlocks.push_back( bdHW );
+         AliHLTUInt16_t*outputHWPtr=(AliHLTUInt16_t*)(outputPtr+dataOffsetBeforeHW);
+         memcpy(outputHWPtr,&fHwAddressList[0],sizeOfHWArray);
+         AliHLTComponentBlockData bdHW;
+         FillBlockData( bdHW );
+         bdHW.fOffset = dataOffsetBeforeHW;
+         bdHW.fSize = sizeOfHWArray;
+         bdHW.fDataType = kAliHLTDataTypeHwAddr16;
+         bdHW.fSpecification = iter->fSpecification;
+         Logging( kHLTLogDebug, "HLT::TPCZeroSuppressionComponent::DoEvent", "Event received", 
+                  "Event 0x%08LX (%Lu) output data block %lu of %lu bytes at offset %lu",
+                  evtData.fEventID, evtData.fEventID, ndx,size ,0);
+         outputBlocks.push_back( bdHW );
+       }
+       size = dataOffsetBeforeHW+sizeOfHWArray;
+
+      } else {
+       size=0;
+      }
+      fDigitReader->Reset();
     }
-    size = dataOffsetBeforeHW+sizeOfHWArray;
 
-  } else {
-    size=0;
-  }
   return 0;
 }
diff --git a/HLT/TPCLib/macros/activePadsTest.C b/HLT/TPCLib/macros/activePadsTest.C
new file mode 100644 (file)
index 0000000..fa90518
--- /dev/null
@@ -0,0 +1,164 @@
+// $Id: dumpTPCDigits.C 24993 2008-04-09 00:54:41Z richterm $
+
+//**************************************************************************
+//* This file is property of and copyright by the ALICE HLT Project        * 
+//* ALICE Experiment at CERN, All rights reserved.                         *
+//*                                                                        *
+//* Primary Authors Kenneth Aamodt <kenneth.aamodt@cern.ch>                *
+//*                  for The ALICE HLT Project.                            *
+//*                                                                        *
+//* 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.                  *
+//**************************************************************************
+
+/** 
+ * @file   activePadsTest.C
+ * @author Kenneth.Aamodt@cern.ch
+ * @date   
+ * @brief  Test macro of the active pad selection
+ *
+ * The macro reads the simulated TPC digits from the RunLoader and
+ * prints the digit info to stout.
+ *
+ * The macro reads ddl data and apply zerosuppression on it. The zerosuppression
+ * component then ships out a list of pads in addition to the zerosuppressed data.
+ * This list of pads is here used in combination with the original raw data to
+ * remove all pads with no data surviving the zerosuppression with the altro 
+ * selection component. This is to study undershoot of signals etc. The output of
+ * altro selection component is the NON zerosuppressed data of all the pads which
+ * there should be a signal in. To test this the macro runs in several steps. 
+ * Point 3 and 4 has to be done in this way to avoid confusion in what ddl data is 
+ * read by the component. 
+ * 1. read the data.
+ * 2. dump it to file. (will be compared to the zerosuppressed data later)
+ * 3. apply zerosuppression producing activepads list
+ * 4. apply zerosuppression producing zerosuppressed data.
+ * 5. dump the data from 4. to file
+ * 6. send the active pad list together with the original data to the altro selection component
+ * 7. dump the reduced data to file
+ * 8. again apply zero suppression to this reduced data
+ * 9. dump the result from zero suppression from 8.(on the reduced data)
+ * 10. compare the outputs from 2 and 7 at see that they are different (if not; this is not a good test) (diff dump1/ev.... dump2/ev...)
+ * 11. compare the outputs from 5. and 9. to see that they are alike. (diff dump3/ev... dump4/ev..)
+ *
+ * NB: 10. and 11. must by now be done manually.... will change soon 
+ * aliroot -b -q activePadsTest.C
+ *
+ */
+
+void activePadsTest(const char* input="./"){
+  
+  if (!input) {
+    cerr << "please specify input or run without arguments" << endl;
+    return;
+  }
+  
+  
+  /////////////////////////////////////////////////////////////////////////////////////////////////
+  // 
+  // init the HLT system in order to define the analysis chain below
+  //
+  gSystem->Load("libHLTrec.so");
+  AliHLTSystem* gHLT=AliHLTReconstructorBase::GetInstance();
+
+//   AliCDBManager* pManager=AliCDBManager::Instance(NULL, 0);
+//   pManager->SetRun(0);
+
+  ///////////////////////////////////////////////////////////////////////////////////////////////////
+  //
+  // define the analysis chain to be run
+  //
+    
+  int iMinSlice=8; 
+  int iMaxSlice=8;
+  int iMinPart=2;
+  int iMaxPart=2;
+  TString digitDumpInput_OriginalData;
+  TString digitDumpInput_AfterAPSelection;
+  TString digitDumpInput_ZeroSuppressedOriginalData;
+  TString digitDumpInput_ZerosuppressedAPSelectionData;
+  TString dumpHwAddressInput;
+
+  for (int slice=iMinSlice; slice<=iMaxSlice; slice++) {
+    for (int part=iMinPart; part<=iMaxPart; part++) {
+      TString arg, publisher, inputAltroSelection, zsactivepadlist, zsoriginaldata, altroChannelSelector, zsACSdata, zsACSdataOutput;
+      // digit publisher components
+      int ddlno=768;
+      if (part>1) ddlno+=72+4*slice+(part-2);
+      else ddlno+=2*slice+part;
+      arg.Form("-minid %d -datatype 'DDL_RAW ' 'TPC '  -dataspec 0x%02x%02x%02x%02x", ddlno, slice, slice, part, part);
+
+      publisher.Form("DP_%02d_%d", slice, part);
+      AliHLTConfiguration pubconf(publisher.Data(), "AliRawReaderPublisher", NULL , arg.Data());
+      if(digitDumpInput_OriginalData.Length() >0) digitDumpInput_OriginalData += " ";
+      digitDumpInput_OriginalData += publisher;
+      if(inputAltroSelection.Length() >0) inputAltroSelection += " ";
+      inputAltroSelection += publisher;
+
+      // zero suppression component (3.)
+      zsactivepadlist.Form("ZSAP_%02d_%d", slice, part);
+      AliHLTConfiguration cfconf(zsactivepadlist.Data(), "TPCZeroSuppression", publisher.Data(), "signal-threshold 2 start-timebin 70 end-timebin 900 -skip-sending-data -send-hw-list");
+      if (inputAltroSelection.Length()>0) inputAltroSelection+=" ";
+      inputAltroSelection+=zsactivepadlist;
+      if (dumpHwAddressInput.Length()>0) dumpHwAddressInput+=" ";
+      dumpHwAddressInput+=zsactivepadlist;
+    
+      // zero suppression component (4.)
+      zsoriginaldata.Form("ZSDDL_%02d_%d", slice, part);
+      AliHLTConfiguration cfconf(zsoriginaldata.Data(), "TPCZeroSuppression", publisher.Data(), "signal-threshold 2 start-timebin 70 end-timebin 900");
+      if(digitDumpInput_ZeroSuppressedOriginalData.Length() >0) digitDumpInput_ZeroSuppressedOriginalData += " ";
+      digitDumpInput_ZeroSuppressedOriginalData += zsoriginaldata;
+
+      //altro channel selector
+      altroChannelSelector.Form("ACS_%02d_%d", slice, part);
+      AliHLTConfiguration cfconf(altroChannelSelector.Data(), "AltroChannelSelector", inputAltroSelection.Data(), "");
+      if(zsACSdata.Length() >0) zsACSdata += " ";
+      zsACSdata+= altroChannelSelector;
+      if(digitDumpInput_AfterAPSelection.Length() >0) digitDumpInput_AfterAPSelection += " ";
+      digitDumpInput_AfterAPSelection += altroChannelSelector;
+
+      // zero suppression component (8.)
+      zsACSdataOutput.Form("ZSACS_%02d_%d", slice, part);
+      AliHLTConfiguration cfconf(zsACSdataOutput.Data(), "TPCZeroSuppression", zsACSdata.Data(), "signal-threshold 2 start-timebin 70 end-timebin 900");
+      if(digitDumpInput_ZerosuppressedAPSelectionData.Length() >0) digitDumpInput_ZerosuppressedAPSelectionData += " ";
+      digitDumpInput_ZerosuppressedAPSelectionData += zsACSdataOutput;
+      
+    }
+  }
+  //Dumping data (2.)
+  AliHLTConfiguration dump1("Dump1", "TPCDigitDump", digitDumpInput_OriginalData.Data() , "-digitreader packed -directory dump1 -unsorted -concatenate-blocks");
+  //Dumping data (7.)
+  AliHLTConfiguration dump2("Dump2", "TPCDigitDump", digitDumpInput_AfterAPSelection.Data() , "-digitreader packed -directory dump2 -unsorted -concatenate-blocks");
+  //Dumping data (5.)
+  AliHLTConfiguration dump3("Dump3", "TPCDigitDump", digitDumpInput_ZeroSuppressedOriginalData.Data() , "-digitreader packed -directory dump3 -unsorted -concatenate-blocks");
+  //Dumping data (9.)
+  AliHLTConfiguration dump4("Dump4", "TPCDigitDump", digitDumpInput_ZerosuppressedAPSelectionData.Data() , "-digitreader packed -directory dump4 -unsorted -concatenate-blocks");
+  //Dumping hw lists
+  AliHLTConfiguration dump5("Dump5", "FileWriter", dumpHwAddressInput.Data() , "-directory hwlists");
+
+
+  ///////////////////////////////////////////////////////////////////////////////////////////////////
+  //
+  // Init and run the reconstruction
+  // All but HLT reconstruction is switched off
+  //
+  AliReconstruction rec;
+  rec.SetInput(input);
+  rec.SetRunVertexFinder(kFALSE);
+  rec.SetRunLocalReconstruction("HLT");
+  rec.SetRunTracking("");
+  rec.SetLoadAlignFromCDB(0);
+  rec.SetRunQA(":");
+  AliMagFMaps* field = new AliMagFMaps("Maps","Maps", 2, 1., 10., AliMagFMaps::k5kG);
+  AliTracker::SetFieldMap(field,kTRUE);
+  //rec.SetFillESD("HLT");
+  rec.SetFillESD("");
+  rec.SetFillTriggerESD(false);
+  rec.SetOption("HLT", "libAliHLTUtil.so libAliHLTRCU.so libAliHLTTPC.so loglevel=0x7c chains=Dump1,Dump2,Dump3,Dump4,Dump5");
+  rec.Run();
+}