Renaming AliHLTReconstructorBase to AliHLTPluginBase to reflect the
authorrichterm <richterm@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 14 May 2009 07:21:26 +0000 (07:21 +0000)
committerrichterm <richterm@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 14 May 2009 07:21:26 +0000 (07:21 +0000)
more common role. The change is backward campatible in order to run
macros of older AliRoot versions.

Adding the AliHLTPluginBase to AliHLTSimulation in order to support
definition of HLT chains within the same macro.

Incorporating chain definition into sim-hlt-tpc.C macro and deleting
separate conf-tpc-esd.C macro. Removing command line initialization
for magnetic field -> rely on OCDB object.

35 files changed:
HLT/BASE/AliHLTPluginBase.cxx [new file with mode: 0644]
HLT/BASE/AliHLTPluginBase.h [new file with mode: 0644]
HLT/BASE/AliHLTReconstructorBase.cxx
HLT/BASE/AliHLTReconstructorBase.h
HLT/CMake_libHLTbase.txt
HLT/ITS/macros/rec-sdd-from-hltout.C
HLT/ITS/macros/rec-spd-cluster.C
HLT/ITS/macros/rec-ssd-cluster.C
HLT/MUON/macros/HLToutputTodHLTRootObjects.C
HLT/TPCLib/macros/activePadsTest.C
HLT/TPCLib/macros/cal-hlt-tpc-offline.C
HLT/TPCLib/macros/conf-tpc-esd.C [deleted file]
HLT/TPCLib/macros/histogramHandlerTest.C
HLT/TPCLib/macros/noiseMapHistoHandler.C
HLT/TPCLib/macros/rec-hlt-tpc-ca.C
HLT/TPCLib/macros/rec-hlt-tpc-offline.C
HLT/TPCLib/macros/rec-hlt-tpc-tracks.C
HLT/TPCLib/macros/rec-hlt-tpc.C
HLT/TPCLib/macros/sim-hlt-tpc.C
HLT/TPCLib/test/compareDigitReaders.C
HLT/benchmark/macros/bench-externaltrackparam-sequence.C
HLT/exa/extract-ddlraw.C
HLT/exa/extract-hltout-payload.C
HLT/exa/hltout-collect-esd.C
HLT/exa/publish-rawreader-data.C
HLT/exa/rec-from-hltout.C
HLT/exa/split-hltout.C
HLT/global/macros/rec-hlt-global-merger.C
HLT/libHLTbase.pkg
HLT/rec/AliHLTReconstructor.cxx
HLT/rec/AliHLTReconstructor.h
HLT/rec/AliRawReaderHLT.cxx
HLT/rec/AliRawReaderHLT.h
HLT/sim/AliHLTSimulation.cxx
HLT/sim/AliHLTSimulation.h

diff --git a/HLT/BASE/AliHLTPluginBase.cxx b/HLT/BASE/AliHLTPluginBase.cxx
new file mode 100644 (file)
index 0000000..7fb83f9
--- /dev/null
@@ -0,0 +1,64 @@
+// $Id$
+
+//**************************************************************************
+//* This file is property of and copyright by the ALICE HLT Project        * 
+//* ALICE Experiment at CERN, All rights reserved.                         *
+//*                                                                        *
+//* Primary Authors: Matthias Richter <Matthias.Richter@ift.uib.no>        *
+//*                  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   AliHLTPluginBase.cxx
+    @author Matthias Richter
+    @date   
+    @brief  Base class for AliRoot HLT plugins.
+*/
+
+#include "AliHLTPluginBase.h"
+#include "AliHLTSystem.h"
+
+/** ROOT macro for the implementation of ROOT specific class methods */
+ClassImp(AliHLTPluginBase)
+
+AliHLTPluginBase::AliHLTPluginBase()
+{
+  // see header file for class documentation
+  // or
+  // refer to README to build package
+  // or
+  // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
+  fNofInstances++;
+}
+
+AliHLTPluginBase::~AliHLTPluginBase()
+{
+  // see header file for class documentation
+  if (--fNofInstances<=0) delete fpSystem;
+  fpSystem=NULL;
+}
+
+void AliHLTPluginBase::InitInstance()
+{
+  // see header file for class documentation
+  if (!fpSystem) fpSystem=new AliHLTSystem;
+}
+
+AliHLTSystem* AliHLTPluginBase::GetInstance()
+{
+  // see header file for class documentation
+  if (!fpSystem) InitInstance();
+  return fpSystem;
+}
+
+
+AliHLTSystem* AliHLTPluginBase::fpSystem=NULL;
+
+int AliHLTPluginBase::fNofInstances=0;
diff --git a/HLT/BASE/AliHLTPluginBase.h b/HLT/BASE/AliHLTPluginBase.h
new file mode 100644 (file)
index 0000000..f401727
--- /dev/null
@@ -0,0 +1,67 @@
+// $Id$
+
+#ifndef ALIHLTPLUGINBASE_H
+#define ALIHLTPLUGINBASE_H
+//* This file is property of and copyright by the ALICE HLT Project        * 
+//* ALICE Experiment at CERN, All rights reserved.                         *
+//* See cxx source for full Copyright notice                               *
+
+/** @file   AliHLTPluginBase.h
+    @author Matthias Richter
+    @date   
+    @brief  Base class for AliRoot HLT plugins.
+*/
+
+// see below for class documentation
+// or
+// refer to README to build package
+// or
+// visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
+
+#include "TObject.h"
+
+class AliHLTSystem;
+
+/**
+ * @class AliHLTPluginBase
+ * Base class for AliRoot HLT plugins.
+ *
+ * In order to allow definitions of HLT chains in the same macro as
+ * the simulation/reconstruction, a global instance of AliHLTSystem
+ * is required to make the registration of configurations work.
+ *
+ * AliHLTPlugin, AliRawReaderHLT and AliHLTSimulation all use
+ * the global AliHLTSystem instance hosted by this base class.
+ */
+class AliHLTPluginBase {
+ public:
+  AliHLTPluginBase();
+  /** destructor */
+  virtual ~AliHLTPluginBase();
+
+  /**
+   * Init the global AliHLTSystem instance.
+   */
+  static void InitInstance();
+
+  /**
+   * Get the global AliHLTSystem instance.
+   */
+  static AliHLTSystem* GetInstance();
+
+ protected:
+
+ private:
+  /** copy constructor prohibited */
+  AliHLTPluginBase(const AliHLTPluginBase& src);
+  /** assignment operator prohibited */
+  AliHLTPluginBase& operator=(const AliHLTPluginBase& src);
+
+  static AliHLTSystem* fpSystem; //! HLT steering object
+
+  static int fNofInstances;
+
+  ClassDef(AliHLTPluginBase, 0)   // base class for the HLT reconstruction
+};
+
+#endif
index e3518287a08859bde5f143e78091db506b5a2c58..e78cc3c5bfd4f5b3eebf3bd7b95b2df8b63aad3a 100644 (file)
 /** @file   AliHLTReconstructorBase.cxx
     @author Matthias Richter
     @date   
-    @brief  Base class for HLT reconstruction classes.
+    @brief  AliHLTPluginBase child for backward compatibility.
 */
 
 #include "AliHLTReconstructorBase.h"
-#include "AliHLTSystem.h"
 
 /** ROOT macro for the implementation of ROOT specific class methods */
 ClassImp(AliHLTReconstructorBase)
@@ -35,30 +34,9 @@ AliHLTReconstructorBase::AliHLTReconstructorBase()
   // refer to README to build package
   // or
   // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
-  fNofInstances++;
 }
 
 AliHLTReconstructorBase::~AliHLTReconstructorBase()
 {
   // see header file for class documentation
-  if (--fNofInstances<=0) delete fpSystem;
-  fpSystem=NULL;
 }
-
-void AliHLTReconstructorBase::InitInstance()
-{
-  // see header file for class documentation
-  if (!fpSystem) fpSystem=new AliHLTSystem;
-}
-
-AliHLTSystem* AliHLTReconstructorBase::GetInstance()
-{
-  // see header file for class documentation
-  if (!fpSystem) InitInstance();
-  return fpSystem;
-}
-
-
-AliHLTSystem* AliHLTReconstructorBase::fpSystem=NULL;
-
-int AliHLTReconstructorBase::fNofInstances=0;
index 69eb99da17128fa177eef0885697c6501dbb509e..bb546b9c45a08fb180d6ed1260d7a49f711232ea 100644 (file)
@@ -9,7 +9,7 @@
 /** @file   AliHLTReconstructorBase.h
     @author Matthias Richter
     @date   
-    @brief  Base class for HLT reconstruction classes.
+    @brief  AliHLTPluginBase child for backward compatibility.
 */
 
 // see below for class documentation
 // or
 // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
 
-#include "TObject.h"
-
-class AliHLTSystem;
+#include "AliHLTPluginBase.h"
 
 /**
  * @class AliHLTReconstructorBase
- * Base class for HLT reconstruction classes. AliHLTReconstructor and
- * AliRawReaderHLT both use the global AliHLTSystem instance. This
- * base class hosts the global instance.
+ * This class was the former name of the base class for HLT
+ * reconstruction instances. It has evolved to a more general
+ * 'plugin' base class and the name has been changed to
+ * AliHLTPluginBase
  */
-class AliHLTReconstructorBase {
+class AliHLTReconstructorBase : public AliHLTPluginBase {
  public:
   AliHLTReconstructorBase();
-  /** destructor */
-  virtual ~AliHLTReconstructorBase();
-
-  /**
-   * Init the global AliHLTSystem instance.
-   */
-  static void InitInstance();
-
-  /**
-   * Get the global AliHLTSystem instance.
-   */
-  static AliHLTSystem* GetInstance();
+  ~AliHLTReconstructorBase();
 
  protected:
 
  private:
-  /** copy constructor prohibited */
-  AliHLTReconstructorBase(const AliHLTReconstructorBase& src);
-  /** assignment operator prohibited */
-  AliHLTReconstructorBase& operator=(const AliHLTReconstructorBase& src);
-
-  static AliHLTSystem* fpSystem; //! HLT steering object
-
-  static int fNofInstances;
-
-  ClassDef(AliHLTReconstructorBase, 0)   // base class for the HLT reconstruction
+  ClassDef(AliHLTReconstructorBase, 0)   // AliHLTPluginBase child for backward compatibility
 };
 #endif
index 6daa5bc5eff37b7bb1876b074b5e52de9ab0ec02..07d5bff8a7b4c9a72f0d4b84e082aee6997bbc28 100644 (file)
@@ -5,6 +5,7 @@ BASE/AliHLTComponent.cxx
 BASE/AliHLTComponentHandler.cxx
 BASE/AliHLTSystem.cxx
 BASE/AliHLTReconstructorBase.cxx
+BASE/AliHLTPluginBase.cxx
 BASE/AliHLTProcessor.cxx
 BASE/AliHLTCalibrationProcessor.cxx
 BASE/AliHLTConfiguration.cxx
index 19c7f0b1ecaee76974b202bbfb3015f9f6822471..32fa5823f32f1152f2a41ea37bbaad8c1cf431c8 100644 (file)
@@ -25,8 +25,7 @@ void rec_sdd_from_hltout()
   /////////////////////////////////////////////////////////////////////////
   //
   // setup of the HLT system
-  gSystem->Load("libHLTrec");
-  AliHLTSystem* pHLT=AliHLTReconstructorBase::GetInstance();
+  AliHLTSystem* pHLT=AliHLTPluginBase::GetInstance();
   if (!pHLT) {
     cerr << "fatal error: can not get HLT instance" << endl;
   }
index aa2f0d9fff9a7e45a93f58314d1a5b0ed29ecb67..2feca880ef316c37304ca44c9c45d8512692b78d 100644 (file)
@@ -18,8 +18,7 @@ void rec_spd_cluster(const char* input="./", char* opt="")
   //
   // init the HLT system in order to define the analysis chain below
   //
-  gSystem->Load("libHLTrec.so");
-  AliHLTSystem* gHLT=AliHLTReconstructorBase::GetInstance();
+  AliHLTSystem* gHLT=AliHLTPluginBase::GetInstance();
  
   ///////////////////////////////////////////////////////////////////////////////////////////////////
   //
index 883618f6805b58b80b8ac728407201d67398e665..75df6a19ad64b45569622135b8512b6e0a5ecb8d 100644 (file)
@@ -18,8 +18,7 @@ void rec_ssd_cluster(const char* input="./", char* opt="")
   //
   // init the HLT system in order to define the analysis chain below
   //
-  gSystem->Load("libHLTrec.so");
-  AliHLTSystem* gHLT=AliHLTReconstructorBase::GetInstance();
+  AliHLTSystem* gHLT=AliHLTPluginBase::GetInstance();
  
   ///////////////////////////////////////////////////////////////////////////////////////////////////
   //
index 58a6e349c8748a568774629aee77e91e4b2c5680..e672b88e241f719ee20dcee00f1416038bf50844 100644 (file)
@@ -17,7 +17,7 @@
 // $Id: $
 
 #if !defined(__CINT__) || defined(__MAKECINT__)
-#include "AliHLTReconstructorBase.h"
+#include "AliHLTPluginBase.h"
 #include "AliHLTConfiguration.h"
 #include "AliReconstruction.h"
 #include <iostream>
@@ -54,7 +54,7 @@ void HLToutputTodHLTRootObjects(const char* dataSource = "./", bool dumpBinary =
 {
        // setup of the HLT system
        gSystem->Load("libHLTrec.so");
-       AliHLTSystem* sys = AliHLTReconstructorBase::GetInstance();
+       AliHLTSystem* sys = AliHLTPluginBase::GetInstance();
        if (sys == NULL)
        {
                cerr << "FATAL ERROR: Cannot get HLT system instance." << endl;
index 7db0ea24996c634bb0f74ca8fb2d584737cea8ff..2250d44e811f2e4cce35e8110fe6f028837aa0aa 100644 (file)
@@ -62,8 +62,7 @@ void activePadsTest(const char* input="./"){
   // 
   // init the HLT system in order to define the analysis chain below
   //
-  gSystem->Load("libHLTrec.so");
-  AliHLTSystem* gHLT=AliHLTReconstructorBase::GetInstance();
+  AliHLTSystem* gHLT=AliHLTPluginBase::GetInstance();
 
 //   AliCDBManager* pManager=AliCDBManager::Instance(NULL, 0);
 //   pManager->SetRun(0);
index 461e4ed5a40c81112b592bb7fb76fc4240474d98..0b52610cf26dd06d6efd6f00c78e1fbdf83fe908 100644 (file)
@@ -41,8 +41,7 @@ void cal_hlt_tpc_offline(const char* input="./")
   //
   // init the HLT system in order to define the analysis chain below
   //
-  gSystem->Load("libHLTrec.so");
-  AliHLTSystem* gHLT=AliHLTReconstructorBase::GetInstance();
+  AliHLTSystem* gHLT=AliHLTPluginBase::GetInstance();
 
   //gHLT.SwitchAliLog(0);
 
diff --git a/HLT/TPCLib/macros/conf-tpc-esd.C b/HLT/TPCLib/macros/conf-tpc-esd.C
deleted file mode 100644 (file)
index b5d0726..0000000
+++ /dev/null
@@ -1,111 +0,0 @@
-// $Id$
-/*
- * Configuration macro defining a chain running the HLT Conformal mapping
- * tracker embedded into AliRoot simulation.
- * The reconstruction is done from the TPC digits.
- *
- * Several output options are possible:
- * - sink-writeall FileWriter writing all blocks
- * - sink-esd-file write ESD using the TPCEsdWriter
- * - sink-esd      write ESD using the TPCEsdConverter and EsdCollector
- * - sink-clusters relay cluster blocks to HLTOUT
- *
- * @author Matthias.Richter@ift.uib.no
- * @ingroup alihlt_tpc
- */
-{
-  // load TPCParam from OCDB
-  const char* cdbEntry="TPC/Calib/Parameters";
-  AliCDBManager* pMan=AliCDBManager::Instance();
-  AliTPCParam* pTPCParam=NULL;
-  if (pMan) {
-    AliCDBEntry *pEntry = pMan->Get(cdbEntry);
-    if (pEntry && 
-       pEntry->GetObject() &&
-       (pTPCParam=dynamic_cast<AliTPCParam*>(pEntry->GetObject()))) {
-    } else {
-      HLTWarning("can not load AliTPCParam from CDB entry %s", cdbEntry);
-    }
-  }
-
-  int iMinSlice=0; 
-  int iMaxSlice=35;
-  int iMinPart=0;
-  int iMaxPart=5;
-  TString mergerInput;
-  TString writerInput;
-  TString sinkClusterInput;
-  for (int slice=iMinSlice; slice<=iMaxSlice; slice++) {
-    TString trackerInput;
-    for (int part=iMinPart; part<=iMaxPart; part++) {
-      TString arg, publisher, cf;
-
-      // digit publisher components
-      arg.Form("-slice %d -partition %d", slice, part);
-      publisher.Form("DP_%02d_%d", slice, part);
-      AliHLTConfiguration pubconf(publisher.Data(), "TPCDigitPublisher", NULL , arg.Data());
-
-      // cluster finder components
-      arg="-timebins ";
-      if (pTPCParam) arg+=pTPCParam->GetMaxTBin()+1;
-      else arg+=446; // old simulated data
-      arg+=" -sorted ";
-      cf.Form("CF_%02d_%d", slice, part);
-      AliHLTConfiguration cfconf(cf.Data(), "TPCClusterFinderUnpacked", publisher.Data(), arg.Data());
-      if (trackerInput.Length()>0) trackerInput+=" ";
-      trackerInput+=cf;
-      if (sinkClusterInput.Length()>0) sinkClusterInput+=" ";
-      sinkClusterInput+=cf;
-    }
-    TString tracker;
-    // tracker finder components
-    tracker.Form("TR_%02d", slice);
-    AliHLTConfiguration trackerconf(tracker.Data(), "TPCSliceTracker", trackerInput.Data(), "-pp-run -solenoidBz 0.5");
-    //AliHLTConfiguration trackerconf(tracker.Data(), "TPCCATracker", trackerInput.Data(), "-solenoidBz 0.5");
-
-    //add all trackers to writer input. Include if you would like all slice tracks written.
-    //if (writerInput.Length()>0) writerInput+=" ";
-    //writerInput+=tracker;
-
-    // add all clusterfinders to the writer input
-    if (writerInput.Length()>0) writerInput+=" ";
-    writerInput+=trackerInput;
-
-    if (mergerInput.Length()>0) mergerInput+=" ";
-    mergerInput+=tracker;
-
-  }
-
-  // GlobalMerger component
-  AliHLTConfiguration mergerconf("globalmerger","TPCGlobalMerger",mergerInput.Data(),"");
-
-  if (writerInput.Length()>0) writerInput+=" ";
-  writerInput+="globalmerger";
-
-  //////////////////////////////////////////////////////////////////////////////////////////
-  //
-  // output section
-  //
-
-  //////////////////////////////////////////////////////////////////////////////////////////
-  // sink1: id=sink-writeall write all blocks
-  AliHLTConfiguration sink1("sink-writeall", "FileWriter"   , writerInput.Data(), "-specfmt -subdir=event_%d -blcknofmt=_0x%x -idfmt=_0x%08x");
-
-
-  //////////////////////////////////////////////////////////////////////////////////////////
-  // sink2: id=sink-esd-file write ESD using the TPCEsdWriter
-  AliHLTConfiguration sink2("sink-esd-file", "TPCEsdWriter"   , "globalmerger", "-datafile AliHLTESDs.root");
-
-
-  //////////////////////////////////////////////////////////////////////////////////////////
-  // sink3: id=sink-esd add ESD to HLTOUT using the TPCEsdConverter
-
-  // the esd converter configuration
-  //AliHLTConfiguration sink3("sink-esd", "TPCEsdConverter"   , "globalmerger", "");
-  AliHLTConfiguration sink3("sink-esd", "TPCEsdConverter"   , mergerInput.Data(), "");
-
-
-  //////////////////////////////////////////////////////////////////////////////////////////
-  // sink4: id=sink-clusters add cluster data blocks to HLTOUT
-  AliHLTConfiguration sink4("sink-clusters", "BlockFilter"   , sinkClusterInput.Data(), "-datatype 'CLUSTERS' 'TPC '");
-}
index 076ccc7116f5b1d6f556396c6c5c83d825f7c3c1..7366fe29005a4cc515b76a84f0dfbf9d9d627d4d 100644 (file)
@@ -43,8 +43,7 @@ void histogramHandlerTest(const char* input="./"){
   // 
   // init the HLT system in order to define the analysis chain below
   //
-  gSystem->Load("libHLTrec.so");
-  AliHLTSystem* gHLT=AliHLTReconstructorBase::GetInstance();
+  AliHLTSystem* gHLT=AliHLTPluginBase::GetInstance();
 
   ///////////////////////////////////////////////////////////////////////////////////////////////////
   //
index 8ae26294ad3a5bee8c289477412a1d728369c0c5..f7d6973d1e00b8f4c04a835ac7eacc7958355ad5 100644 (file)
@@ -54,8 +54,7 @@ void noiseMapHistoHandler(const char* input="./"){
   // 
   // init the HLT system in order to define the analysis chain below
   //
-  gSystem->Load("libHLTrec.so");
-  AliHLTSystem* gHLT=AliHLTReconstructorBase::GetInstance();
+  AliHLTSystem* gHLT=AliHLTPluginBase::GetInstance();
 
   ///////////////////////////////////////////////////////////////////////////////////////////////////
   //
index 111817bf0fcf3dc6043c918fb9e70c8453ce32bf..6ad978863765b9f6e3ad9f2b64d5a425e245aff2 100644 (file)
@@ -44,8 +44,7 @@ void rec_hlt_tpc_ca(const char* input="./", bool bUseClusterFinderDecoder=true)
   //
   // init the HLT system in order to define the analysis chain below
   //
-  gSystem->Load("libHLTrec.so");
-  AliHLTSystem* gHLT=AliHLTReconstructorBase::GetInstance();
+  AliHLTSystem* gHLT=AliHLTPluginBase::GetInstance();
 
   ///////////////////////////////////////////////////////////////////////////////////////////////////
   //
index 53a2de9fdb15df78ea28643c7a61597f7450988a..989a51f01690996f650b3181a8880833334c3a24 100644 (file)
@@ -39,8 +39,7 @@ void rec_hlt_tpc_offline(const char* input="./")
   //
   // init the HLT system in order to define the analysis chain below
   //
-  gSystem->Load("libHLTrec.so");
-  AliHLTSystem* gHLT=AliHLTReconstructorBase::GetInstance();
+  AliHLTSystem* gHLT=AliHLTPluginBase::GetInstance();
 
   //gHLT.SwitchAliLog(0);
 
index c0ea263e6ad6d2338ffc5e172fe918b99f269e4a..71acb8750cad2c73c4b14deac26103e610c7cc0e 100644 (file)
@@ -43,8 +43,7 @@ void rec_hlt_tpc_tracks(const char* input="./")
   //
   // init the HLT system in order to define the analysis chain below
   //
-  gSystem->Load("libHLTrec.so");
-  AliHLTSystem* gHLT=AliHLTReconstructorBase::GetInstance();
+  AliHLTSystem* gHLT=AliHLTPluginBase::GetInstance();
 
   ///////////////////////////////////////////////////////////////////////////////////////////////////
   //
index 25c451a9a37164edc642516e9d71c8ca8ded8241..bede1c3227193c536ad45fc01ff00db4607c67ad 100644 (file)
@@ -55,8 +55,7 @@ void rec_hlt_tpc(const char* input="./", char* opt="decoder ESD")
   //
   // init the HLT system in order to define the analysis chain below
   //
-  gSystem->Load("libHLTrec.so");
-  AliHLTSystem* gHLT=AliHLTReconstructorBase::GetInstance();
+  AliHLTSystem* gHLT=AliHLTPluginBase::GetInstance();
  
   ///////////////////////////////////////////////////////////////////////////////////////////////////
   //
index 0a1bc917708cd65def0bb2d86af201de60ba98d3..197d31db6215f2dd81bb7e8bffda57f4ee4547bf 100644 (file)
   AliHLTLogging log;
   //log.SwitchAliLog(0);
 
-  AliSimulation sim;
+  ///////////////////////////////////////////////////////////////////////////////////////////////////
+  ///////////////////////////////////////////////////////////////////////////////////////////////////
+  ///////////////////////////////////////////////////////////////////////////////////////////////////
+  //
+  // init the HLT system in order to define the analysis chain below
+  //
+  AliHLTSystem* gHLT=AliHLTPluginBase::GetInstance();
+
+  ///////////////////////////////////////////////////////////////////////////////////////////////////
+  ///////////////////////////////////////////////////////////////////////////////////////////////////
+  ///////////////////////////////////////////////////////////////////////////////////////////////////
+  //
+  // define the analysis chain
+  //
+
+  // load TPCParam from OCDB
+  const char* cdbEntry="TPC/Calib/Parameters";
+  AliCDBManager* pMan=AliCDBManager::Instance();
+  AliTPCParam* pTPCParam=NULL;
+  if (pMan) {
+    if (!pMan->IsDefaultStorageSet()) {
+      pMan->SetDefaultStorage("local://$ALICE_ROOT/OCDB");
+      pMan->SetRun(0);
+    }
+    AliCDBEntry *pEntry = pMan->Get(cdbEntry);
+    if (pEntry && 
+       pEntry->GetObject() &&
+       (pTPCParam=dynamic_cast<AliTPCParam*>(pEntry->GetObject()))) {
+    } else {
+      HLTWarning("can not load AliTPCParam from CDB entry %s", cdbEntry);
+    }
+  }
+
+  int iMinSlice=0; 
+  int iMaxSlice=35;
+  int iMinPart=0;
+  int iMaxPart=5;
+  TString mergerInput;
+  TString writerInput;
+  TString sinkClusterInput;
+  for (int slice=iMinSlice; slice<=iMaxSlice; slice++) {
+    TString trackerInput;
+    for (int part=iMinPart; part<=iMaxPart; part++) {
+      TString arg, publisher, cf;
+
+      // digit publisher components
+      arg.Form("-slice %d -partition %d", slice, part);
+      publisher.Form("DP_%02d_%d", slice, part);
+      AliHLTConfiguration pubconf(publisher.Data(), "TPCDigitPublisher", NULL , arg.Data());
+
+      // cluster finder components
+      arg="-timebins ";
+      if (pTPCParam) arg+=pTPCParam->GetMaxTBin()+1;
+      else arg+=446; // old simulated data
+      arg+=" -sorted ";
+      cf.Form("CF_%02d_%d", slice, part);
+      AliHLTConfiguration cfconf(cf.Data(), "TPCClusterFinderUnpacked", publisher.Data(), arg.Data());
+      if (trackerInput.Length()>0) trackerInput+=" ";
+      trackerInput+=cf;
+      if (sinkClusterInput.Length()>0) sinkClusterInput+=" ";
+      sinkClusterInput+=cf;
+    }
+    TString tracker;
+    // tracker finder components
+    tracker.Form("TR_%02d", slice);
+    AliHLTConfiguration trackerconf(tracker.Data(), "TPCSliceTracker", trackerInput.Data(), "-pp-run");
+
+    //add all trackers to writer input. Include if you would like all slice tracks written.
+    //if (writerInput.Length()>0) writerInput+=" ";
+    //writerInput+=tracker;
+
+    // add all clusterfinders to the writer input
+    if (writerInput.Length()>0) writerInput+=" ";
+    writerInput+=trackerInput;
+
+    if (mergerInput.Length()>0) mergerInput+=" ";
+    mergerInput+=tracker;
+
+  }
+
+  // GlobalMerger component
+  AliHLTConfiguration mergerconf("globalmerger","TPCGlobalMerger",mergerInput.Data(),"");
 
+  if (writerInput.Length()>0) writerInput+=" ";
+  writerInput+="globalmerger";
+
+  //////////////////////////////////////////////////////////////////////////////////////////
+  //
+  // output section
+  //
+
+  //////////////////////////////////////////////////////////////////////////////////////////
+  // sink1: id=sink-writeall write all blocks
+  AliHLTConfiguration sink1("sink-writeall", "FileWriter"   , writerInput.Data(), "-specfmt -subdir=event_%d -blcknofmt=_0x%x -idfmt=_0x%08x");
+
+
+  //////////////////////////////////////////////////////////////////////////////////////////
+  // sink2: id=sink-esd-file write ESD using the TPCEsdWriter
+  AliHLTConfiguration sink2("sink-esd-file", "TPCEsdWriter"   , "globalmerger", "-datafile AliHLTESDs.root");
+
+
+  //////////////////////////////////////////////////////////////////////////////////////////
+  // sink3: id=sink-esd add ESD to HLTOUT using the TPCEsdConverter
+
+  // the esd converter configuration
+  //AliHLTConfiguration sink3("sink-esd", "TPCEsdConverter"   , "globalmerger", "");
+  AliHLTConfiguration sink3("sink-esd", "TPCEsdConverter"   , mergerInput.Data(), "");
+
+
+  //////////////////////////////////////////////////////////////////////////////////////////
+  // sink4: id=sink-clusters add cluster data blocks to HLTOUT
+  AliHLTConfiguration sink4("sink-clusters", "BlockFilter"   , sinkClusterInput.Data(), "-datatype 'CLUSTERS' 'TPC '");
+
+  ///////////////////////////////////////////////////////////////////////////////////////////////////
+  ///////////////////////////////////////////////////////////////////////////////////////////////////
+  ///////////////////////////////////////////////////////////////////////////////////////////////////
+  //
+  // Init and run the HLT simulation
+  // All but HLT simulation is switched off
+  //
+  AliSimulation sim;
   // switch of simulation and data generation
   // comment all that stuff to also simulate the events and data
   sim.SetRunGeneration(kFALSE);
   sim.SetMakeSDigits("");
   sim.SetMakeDigitsFromHits("");
   sim.SetMakeTrigger("");
+  sim.SetRunQA(":");
+  //sim.SetWriteRawData("HLT TPC", "raw.root", kTRUE);
 
   // set the options for the HLT simulation
   sim.SetRunHLT("libAliHLTUtil.so libAliHLTTPC.so loglevel=0x7c "
-               "config=$ALICE_ROOT/HLT/TPCLib/macros/conf-tpc-esd.C chains=sink-esd,sink-clusters");
+               "chains=sink-esd,sink-clusters");
   sim.Run();
 }
index 8acf852391fdc5fa5ff523f9a1e14ea191df0e5a..98ad6dbee7beacde4c78cf359157871fc8c1b0af 100644 (file)
@@ -62,8 +62,7 @@ int compareDigitReaders(const char* input, int iMinEvent=-1, int iMaxEvent=-1)
   /////////////////////////////////////////////////////////////////////////
   //
   // setup of the HLT system
-  gSystem->Load("libHLTrec");
-  AliHLTSystem* pHLT=AliHLTReconstructorBase::GetInstance();
+  AliHLTSystem* pHLT=AliHLTPluginBase::GetInstance();
   if (!pHLT) {
     cerr << "fatal error: can not get HLT instance" << endl;
   }
index 12a1d21f11f7a2f91b9960b0d95e1914971a096a..31aad9ecd9aa705df2e7a376e240bae325e08461 100644 (file)
@@ -17,8 +17,7 @@ void bench_externaltrackparam_sequence(int events=100)
   //
   // init the HLT system in order to define the analysis chain below
   //
-  gSystem->Load("libHLTrec.so");
-  AliHLTSystem* gHLT=AliHLTReconstructorBase::GetInstance();
+  AliHLTSystem* gHLT=AliHLTPluginBase::GetInstance();
   gHLT->SetGlobalLoggingLevel(0x7c);
 
   ///////////////////////////////////////////////////////////////////////////////////////////////////
index d55b81e7368eb1f6399465bf10b03a638307efd8..66f9d5ed40398b551c5ae494537713007f3277b7 100644 (file)
@@ -58,8 +58,7 @@ void extract_ddlraw(const char* input, int iMinDDLno, int iMaxDDLno)
   /////////////////////////////////////////////////////////////////////////
   //
   // setup of the HLT system
-  gSystem->Load("libHLTrec");
-  AliHLTSystem* pHLT=AliHLTReconstructorBase::GetInstance();
+  AliHLTSystem* pHLT=AliHLTPluginBase::GetInstance();
   if (!pHLT) {
     cerr << "fatal error: can not get HLT instance" << endl;
   }
index 65d2a9d75afadb4aa1df5dc1c9c1b11202e12c5f..fe425a9e5ea97d8940edd0039d64c1ea1e0726f5 100644 (file)
@@ -32,8 +32,7 @@ void extract_hltout_payload(const char* input, const char* selection="", int max
   /////////////////////////////////////////////////////////////////////////
   //
   // setup of the HLT system
-  gSystem->Load("libHLTrec");
-  AliHLTSystem* pHLT=AliHLTReconstructorBase::GetInstance();
+  AliHLTSystem* pHLT=AliHLTPluginBase::GetInstance();
   if (!pHLT) {
     cerr << "fatal error: can not get HLT instance" << endl;
   }
index 902dc4c0de5bb320818ce4cd0e6666759e09cdfd..d68a3e782c1bb3c3f6083b7d714784533cfee7c2 100644 (file)
@@ -27,8 +27,7 @@ void hltout_collect_esd()
   /////////////////////////////////////////////////////////////////////////
   //
   // setup of the HLT system
-  gSystem->Load("libHLTrec");
-  AliHLTSystem* pHLT=AliHLTReconstructorBase::GetInstance();
+  AliHLTSystem* pHLT=AliHLTPluginBase!::GetInstance();
   if (!pHLT) {
     cerr << "fatal error: can not get HLT instance" << endl;
   }
index 1562086a21199c986e7f567a2af7bd503a99205e..c562b64e348d9e5b9934de4874087692a9524f7c 100644 (file)
@@ -47,8 +47,7 @@ void publish_rawreader_data(const char* input, int iMinDDLno, int iMaxDDLno)
   /////////////////////////////////////////////////////////////////////////
   //
   // setup of the HLT system
-  gSystem->Load("libHLTrec");
-  AliHLTSystem* pHLT=AliHLTReconstructorBase::GetInstance();
+  AliHLTSystem* pHLT=AliHLTPluginBase::GetInstance();
   if (!pHLT) {
     cerr << "fatal error: can not get HLT instance" << endl;
   }
index 5ed44149db1b932f2b67fd98cfd76fdefdad3fa9..5c8e29c7b40e4a86acadf839ab22bd0c854e5d7e 100644 (file)
@@ -27,8 +27,7 @@ void rec_from_hltout()
   /////////////////////////////////////////////////////////////////////////
   //
   // setup of the HLT system
-  gSystem->Load("libHLTrec");
-  AliHLTSystem* pHLT=AliHLTReconstructorBase::GetInstance();
+  AliHLTSystem* pHLT=AliHLTPluginBase::GetInstance();
   if (!pHLT) {
     cerr << "fatal error: can not get HLT instance" << endl;
   }
index 7c5dbedd232f0398dcec9d716114b4e148e6c3a0..4e569f7c53d41430c1fa2d35deed912747fb0a2b 100644 (file)
@@ -26,8 +26,7 @@ void split_hltout()
   /////////////////////////////////////////////////////////////////////////
   //
   // setup of the HLT system
-  gSystem->Load("libHLTrec");
-  AliHLTSystem* pHLT=AliHLTReconstructorBase::GetInstance();
+  AliHLTSystem* pHLT=AliHLTPluginBase::GetInstance();
   if (!pHLT) {
     cerr << "fatal error: can not get HLT instance" << endl;
   }
index 18a3a5637e8338dc41506146203ea91196ad85c4..698f4b2372293cc2c2d3e07123e58b62aa97f3be 100644 (file)
@@ -43,8 +43,7 @@ void rec_hlt_global_merger(const char* input="./", bool bUseClusterFinderDecoder
   //
   // init the HLT system in order to define the analysis chain below
   //
-  gSystem->Load("libHLTrec.so");
-  AliHLTSystem* gHLT=AliHLTReconstructorBase::GetInstance();
+  AliHLTSystem* gHLT=AliHLTPluginBase::GetInstance();
   gHLT->SetGlobalLoggingLevel(0x4); 
   /*  enum AliHLTComponentLogSeverity {       
       kHLTLogNone      = 0,
index a6405fd5a269eb9d0502f9e1bd3f94685490050b..6b304164d4b9e92f16f938bee44e97d4b466492b 100644 (file)
@@ -7,6 +7,7 @@ CLASS_HDRS:=    AliHLTComponent.h \
                AliHLTComponentHandler.h \
                AliHLTSystem.h \
                AliHLTReconstructorBase.h \
+               AliHLTPluginBase.h \
                AliHLTProcessor.h \
                AliHLTCalibrationProcessor.h \
                AliHLTConfiguration.h \
index 5a35dc4b5398dfe1922accb3f550b579c7b07486..40e19e071a6c2cd3098c0cad02db6b5ef31369cd 100644 (file)
@@ -39,7 +39,7 @@ ClassImp(AliHLTReconstructor)
 AliHLTReconstructor::AliHLTReconstructor()
   : 
   AliReconstructor(),
-  AliHLTReconstructorBase(),
+  AliHLTPluginBase(),
   fFctProcessHLTOUT(NULL),
   fpEsdManager(NULL)
 { 
@@ -49,7 +49,7 @@ AliHLTReconstructor::AliHLTReconstructor()
 AliHLTReconstructor::AliHLTReconstructor(const char* options)
   : 
   AliReconstructor(),
-  AliHLTReconstructorBase(),
+  AliHLTPluginBase(),
   fFctProcessHLTOUT(NULL),
   fpEsdManager(NULL)
 { 
index 5b9f2d66523ebece3eac924f63523ac474af009c..57176fcf3e7cd3d531967cbc4c27009e895ed147 100644 (file)
@@ -13,7 +13,7 @@
 */
 
 #include "AliReconstructor.h"
-#include "AliHLTReconstructorBase.h"
+#include "AliHLTPluginBase.h"
 
 class AliHLTSystem;
 class AliRawReader;
@@ -190,7 +190,7 @@ class AliHLTEsdManager;
  * @ingroup alihlt_aliroot_reconstruction
  * @section sec_alihltreconstructor_members Class members
  */
-class AliHLTReconstructor: public AliReconstructor, public AliHLTReconstructorBase {
+class AliHLTReconstructor: public AliReconstructor, public AliHLTPluginBase {
 public:
   /** standard constructor */
   AliHLTReconstructor();
index 4a6caa1cac5114b31ce7fecf390193f42b93c099..84644c141a4fe3e8265f7d9b6a0d3cbf871f2261 100644 (file)
@@ -45,7 +45,7 @@ ClassImp(AliRawReaderHLT)
 AliRawReaderHLT::AliRawReaderHLT(AliRawReader* pRawreader, const char* options)
   :
   AliRawReader(),
-  AliHLTReconstructorBase(),
+  AliHLTPluginBase(),
   fpParentReader(pRawreader),
   fOptions(),
   fSystemOptions(),
index 118461c2c32c75657a0cae2c452c2ee0f253a1b1..6f034d0084db6fefb80958299e763e40b776fffc 100644 (file)
@@ -21,7 +21,7 @@
 
 #include "AliHLTDataTypes.h"
 #include "AliRawReader.h"      // RAW, base class
-#include "AliHLTReconstructorBase.h"
+#include "AliHLTPluginBase.h"
 #include "TString.h"
 #include <vector>
 
@@ -116,7 +116,7 @@ class AliHLTOUTHandler;
  *
  * @ingroup alihlt_aliroot_reconstruction
  */
-class AliRawReaderHLT : public AliRawReader, public AliHLTReconstructorBase {
+class AliRawReaderHLT : public AliRawReader, public AliHLTPluginBase {
  public:
   /** constructor */
   AliRawReaderHLT(AliRawReader* pParentReader, const char* options=NULL);
index 653d93c400e35841288a310a3d0809c1144bde4f..b0c56f2c139e6d8fdef53cb8a8f09ce26eef54b4 100644 (file)
@@ -37,6 +37,7 @@
 #include "AliCDBId.h"
 #include "AliCDBMetaData.h"
 #include "AliHLTSystem.h"
+#include "AliHLTPluginBase.h"
 #include "AliRawReaderFile.h"
 #include "AliRawReaderDate.h"
 #include "AliRawReaderRoot.h"
@@ -53,7 +54,7 @@ ClassImp(AliHLTSimulation);
 AliHLTSimulation::AliHLTSimulation()
   :
   fOptions(),
-  fpSystem(NULL),
+  fpPluginBase(new AliHLTPluginBase),
   fpRawReader(NULL)
 {
   // see header file for class documentation
@@ -66,10 +67,9 @@ AliHLTSimulation::AliHLTSimulation()
 AliHLTSimulation::~AliHLTSimulation()
 {
   // see header file for function documentation
-  if (fpSystem) {
-    delete fpSystem;
-  }
-  fpSystem=NULL;
+  if (fpPluginBase) delete fpPluginBase;
+  fpPluginBase=NULL;
+
   if (fpRawReader) {
     delete fpRawReader;
   }
@@ -96,12 +96,17 @@ int AliHLTSimulation::Init(AliRunLoader* pRunLoader, const char* options)
   fOptions=options;
   TString sysOp;
 
-  if (!fpSystem) fpSystem=new AliHLTSystem;
-  if (!fpSystem) {
-    AliError("can not create AliHLTSystem object");
+  if(!fpPluginBase) {
+    AliError("internal initialization failed");
+    return -EINVAL;
+  }
+
+  AliHLTSystem* pSystem=fpPluginBase->GetInstance();
+  if (!pSystem) {
+    AliError("can not get AliHLTSystem instance");
     return -ENOMEM;
   }
-  if (fpSystem->CheckStatus(AliHLTSystem::kError)) {
+  if (pSystem->CheckStatus(AliHLTSystem::kError)) {
     AliError("HLT system in error state");
     return -EFAULT;
   }
@@ -178,13 +183,13 @@ int AliHLTSimulation::Init(AliRunLoader* pRunLoader, const char* options)
   }
 
   // scan options
-  if (fpSystem->ScanOptions(sysOp.Data())<0) {
+  if (pSystem->ScanOptions(sysOp.Data())<0) {
     AliError("error setting options for HLT system");
     return -EINVAL;    
   }
 
-  if (!fpSystem->CheckStatus(AliHLTSystem::kReady)) {
-    if ((fpSystem->Configure(fpRawReader, pRunLoader))<0) {
+  if (!pSystem->CheckStatus(AliHLTSystem::kReady)) {
+    if ((pSystem->Configure(fpRawReader, pRunLoader))<0) {
       AliError("error during HLT system configuration");
       return -EFAULT;
     }
@@ -197,6 +202,11 @@ int AliHLTSimulation::Init(AliRunLoader* pRunLoader, const char* options)
 int AliHLTSimulation::Run(AliRunLoader* pRunLoader)
 {
   // HLT reconstruction for simulated data  
+  if(!fpPluginBase) {
+    AliError("internal initialization failed");
+    return -EINVAL;
+  }
+
   if(!pRunLoader) {
     AliError("Missing RunLoader! 0x0");
     return -EINVAL;
@@ -205,24 +215,30 @@ int AliHLTSimulation::Run(AliRunLoader* pRunLoader)
   int nEvents = pRunLoader->GetNumberOfEvents();
   int iResult=0;
 
-  if (fpSystem->CheckStatus(AliHLTSystem::kError)) {
+  AliHLTSystem* pSystem=fpPluginBase->GetInstance();
+  if (!pSystem) {
+    AliError("can not get AliHLTSystem instance");
+    return -ENOMEM;
+  }
+
+  if (pSystem->CheckStatus(AliHLTSystem::kError)) {
     AliError("HLT system in error state");
     return -EFAULT;
   }
 
   // Note: the rawreader is already placed at the first event
-  if ((iResult=fpSystem->Reconstruct(1, pRunLoader, fpRawReader))>=0) {
-    fpSystem->FillESD(0, pRunLoader, NULL);
+  if ((iResult=pSystem->Reconstruct(1, pRunLoader, fpRawReader))>=0) {
+    pSystem->FillESD(0, pRunLoader, NULL);
     for (int i=1; i<nEvents; i++) {
       if (fpRawReader && !fpRawReader->NextEvent()) {
        AliError("mismatch in event count, rawreader corrupted");
        break;
       }
-      fpSystem->Reconstruct(1, pRunLoader, fpRawReader);
-      fpSystem->FillESD(i, pRunLoader, NULL);
+      pSystem->Reconstruct(1, pRunLoader, fpRawReader);
+      pSystem->FillESD(i, pRunLoader, NULL);
     }
     // send specific 'event' to execute the stop sequence
-    fpSystem->Reconstruct(0, NULL, NULL);
+    pSystem->Reconstruct(0, NULL, NULL);
   }
   return iResult;
 }
index 1bcbe19093d9848508d80bcf1f275189f1a17e83..9a955f932e6b1d3a08be21a7498f3bfbbb1a6311 100644 (file)
@@ -60,7 +60,7 @@
 #include "TObject.h"
 #include "TString.h"
 class AliRunLoader;
-class AliHLTSystem;
+class AliHLTPluginBase;
 class AliRawReader;
 
 /**
@@ -116,13 +116,13 @@ class AliHLTSimulation : public TObject {
   /* current options */
   TString fOptions;                                                   //!transient
 
-  /* HLT steering object */
-  AliHLTSystem* fpSystem;                                             //!transient
+  /** base class for AliRoot HLT plugins */
+  AliHLTPluginBase* fpPluginBase;                                     //!transient
 
-  /* RAW reader instance for chains which need RAW data as input */
-  AliRawReader* fpRawReader;                                            //!transient
+  /** RAW reader instance for chains which need RAW data as input */
+  AliRawReader* fpRawReader;                                          //!transient
 
-  ClassDef(AliHLTSimulation, 1)
+  ClassDef(AliHLTSimulation, 2)
 };
 
 #define ALIHLTSIMULATION_LIBRARY             "libHLTsim.so"