adding TPC offline tracking component for calibration and using TObject arrays for...
authorrichterm <richterm@f7af4fe6-9843-0410-8265-dc069ae4e863>
Sat, 2 Aug 2008 07:14:01 +0000 (07:14 +0000)
committerrichterm <richterm@f7af4fe6-9843-0410-8265-dc069ae4e863>
Sat, 2 Aug 2008 07:14:01 +0000 (07:14 +0000)
HLT/TPCLib/AliHLTTPCAgent.cxx
HLT/TPCLib/macros/cal-hlt-tpc-offline.C
HLT/TPCLib/offline/AliHLTTPCOfflineCalibrationComponent.cxx
HLT/TPCLib/offline/AliHLTTPCOfflineCalibrationComponent.h
HLT/TPCLib/offline/AliHLTTPCOfflineTrackerCalibComponent.cxx [new file with mode: 0644]
HLT/TPCLib/offline/AliHLTTPCOfflineTrackerCalibComponent.h [new file with mode: 0644]
HLT/TPCLib/offline/AliHLTTPCOfflineTrackerComponent.cxx
HLT/TPCLib/offline/AliHLTTPCOfflineTrackerComponent.h
HLT/libAliHLTTPC.pkg

index 731bbe1..fd9c4ec 100644 (file)
@@ -56,6 +56,7 @@ AliHLTTPCAgent gAliHLTTPCAgent;
 #include "AliHLTTPCEsdWriterComponent.h"
 #include "AliHLTTPCOfflineClustererComponent.h"
 #include "AliHLTTPCOfflineTrackerComponent.h"
+#include "AliHLTTPCOfflineTrackerCalibComponent.h"
 #include "AliHLTTPCOfflineCalibrationComponent.h"
 #include "AliHLTTPCClusterHistoComponent.h"
 #include "AliHLTTPCNoiseMapComponent.h"
@@ -217,6 +218,7 @@ int AliHLTTPCAgent::RegisterComponents(AliHLTComponentHandler* pHandler) const
   pHandler->AddComponent(new AliHLTTPCEsdWriterComponent::AliConverter);
   pHandler->AddComponent(new AliHLTTPCOfflineClustererComponent);
   pHandler->AddComponent(new AliHLTTPCOfflineTrackerComponent);
+  pHandler->AddComponent(new AliHLTTPCOfflineTrackerCalibComponent);
   pHandler->AddComponent(new AliHLTTPCOfflineCalibrationComponent);
   pHandler->AddComponent(new AliHLTTPCClusterHistoComponent);
   pHandler->AddComponent(new AliHLTTPCNoiseMapComponent);
index 95c5cd3..1c83d94 100644 (file)
@@ -109,7 +109,7 @@ void cal_hlt_tpc_offline(const char* input="./")
   // one global tracker component
   TString tracker;
   tracker.Form("Global_TR");
-  AliHLTConfiguration trackerconf(tracker.Data(), "TPCOfflineTracker", trackerInput.Data(), "");
+  AliHLTConfiguration trackerconf(tracker.Data(), "TPCOfflineTrackerCalib", trackerInput.Data(), "");
   if (writerInput.Length()>0) writerInput+=" ";
   calibratorInput+=tracker;
 
index d5ae6fa..f993f52 100644 (file)
@@ -72,7 +72,7 @@ void AliHLTTPCOfflineCalibrationComponent::GetInputDataTypes( vector<AliHLTCompo
 {
   // get input data type
   list.clear();
-  list.push_back(kAliHLTDataTypeESDObject|kAliHLTDataOriginTPC/*AliHLTTPCDefinitions::fgkOfflineClustersDataType*/);
+  list.push_back(kAliHLTDataTypeTObjArray|kAliHLTDataOriginTPC/*TObjArray of seeds*/);
 }
 
 AliHLTComponentDataType AliHLTTPCOfflineCalibrationComponent::GetOutputDataType()
@@ -179,12 +179,11 @@ int AliHLTTPCOfflineCalibrationComponent::ProcessCalibration(const AliHLTCompone
   HLTInfo("ProcessCalibration processing data");
 
   int iResult=0;
-  AliESDEvent *pESD =0;
-  AliESDfriend* pESDfriend=0;
+  TObjArray *pSeedsArray=0;
   int slice, patch;
   
   // calculate specification
-  const AliHLTComponentBlockData* pBlock=GetFirstInputBlock(kAliHLTDataTypeESDObject|kAliHLTDataOriginTPC); 
+  const AliHLTComponentBlockData* pBlock=GetFirstInputBlock(kAliHLTDataTypeTObjArray|kAliHLTDataOriginTPC); 
   if(!pBlock) {
      HLTError("Cannot get first data block 0x%08x ",pBlock);
      iResult=-ENOMEM; return iResult;
@@ -196,17 +195,13 @@ int AliHLTTPCOfflineCalibrationComponent::ProcessCalibration(const AliHLTCompone
  
   if (fTPCcalibAlign && fTPCcalibTracksGain && fTPCcalibTracks) 
   {
-    // loop over input data blocks: ESD events
-    for (TObject *pObj = (TObject *)GetFirstInputObject(kAliHLTDataTypeESDObject|kAliHLTDataOriginTPC,"ESD",0);
+    // loop over input data blocks: TObjArray of TPCseed 
+    for (TObject *pObj = (TObject *)GetFirstInputObject(kAliHLTDataTypeTObjArray|kAliHLTDataOriginTPC,"TObjArray",0);
         pObj !=0 && iResult>=0;
         pObj = (TObject *)GetNextInputObject(0)) {
-      pESD = dynamic_cast<AliESDEvent*>(pObj);
-      if (!pESD) continue;
 
-      // get standard ESD content
-      pESD->GetStdContent();
-
-      HLTInfo("load %d esd tracks from block %s 0x%08x", pESD->GetNumberOfTracks(), DataType2Text(GetDataType(pObj)).c_str(), GetSpecification(pObj));
+      pSeedsArray = dynamic_cast<TObjArray*>(pObj);
+      if (!pSeedsArray) continue;
 
       slice=AliHLTTPCDefinitions::GetMinSliceNr(GetSpecification(pObj));
       patch=AliHLTTPCDefinitions::GetMinPatchNr(GetSpecification(pObj));
@@ -216,35 +211,19 @@ int AliHLTTPCOfflineCalibrationComponent::ProcessCalibration(const AliHLTCompone
       if(patch < minPatch) minPatch=patch;
       if(patch > maxPatch) maxPatch=patch;
 
-      // get ESD fiends
-      pESDfriend=static_cast<AliESDfriend*>(pESD->FindListObject("AliESDfriend"));
-      if (!pESDfriend) {
-         HLTError("Cannot load ESD friends  0x%08x", pESDfriend);
-         iResult=-ENOMEM; 
-        return iResult;
-      }
-      HLTInfo("load %d esd friend tracks from 0x%08x", pESDfriend->GetNumberOfTracks(), pESDfriend);
-
       // get TPC seeds 
-      Int_t n=pESD->GetNumberOfTracks();
-      for (Int_t i=0;i<n;++i) {
-         AliESDfriendTrack *friendTrack=pESDfriend->GetTrack(i);
-
-        if(!friendTrack) continue;
-         HLTInfo("Process calibration on friend track 0x%08x", friendTrack);
-
-         TObject *calibObject=0;
-         AliTPCseed *seed=0;
-         for (Int_t j=0;(calibObject=friendTrack->GetCalibObject(j));++j) {
-            if ((seed=dynamic_cast<AliTPCseed*>(calibObject))!=0) break;
-        }
-         if (seed) {
-            HLTInfo("Process calibration on seed 0x%08x", seed);
-            fTPCcalibAlign->Process(seed);
-            fTPCcalibTracksGain->Process(seed);
-            fTPCcalibTracks->Process(seed);
-        }
+      Int_t nseed = pSeedsArray->GetEntriesFast();
+      HLTInfo("Number TPC seeds %d",nseed);
+
+      for(Int_t i=0; i<nseed; ++i) {
+        AliTPCseed *seed = (AliTPCseed*)pSeedsArray->UncheckedAt(i);
+        if(!seed) continue;
+          HLTInfo("Process calibration on seed 0x%08x", seed);
+          fTPCcalibAlign->Process(seed);
+          fTPCcalibTracksGain->Process(seed);
+          fTPCcalibTracks->Process(seed);
       }
+
       // calculate specification from the specification of input data blocks
         AliHLTUInt32_t iSpecification = AliHLTTPCDefinitions::EncodeDataSpecification(minSlice, maxSlice, minPatch, maxPatch);
 
@@ -253,6 +232,9 @@ int AliHLTTPCOfflineCalibrationComponent::ProcessCalibration(const AliHLTCompone
        PushBack((TObject*)fTPCcalibTracksGain,AliHLTTPCDefinitions::fgkOfflineCalibTracksGainDataType,iSpecification);
        PushBack((TObject*)fTPCcalibTracks,AliHLTTPCDefinitions::fgkOfflineCalibTracksDataType,iSpecification);
 
+      // reset standard ESD content    
+      pSeedsArray->Delete();
+
     }// end loop over input objects
     
   } else {
index 3d8079e..0b48306 100644 (file)
  * TPC calibration component
  *
  * The component interfaces of the TPC offline calibration components
- * to the online HLT. The component expects a full AliESD event containing the
- * TPCseed track information. The outputs are calibration components.
+ * to the online HLT. The component expects a TPCseed object.
+ * The outputs are calibration components.
  *
  * <h2>General properties:</h2>
  *
  * Component ID: \b TPCOfflineCalibration <br>
  * Library: \b libAliHLTTPC.so     <br>
- * Input Data Types: @ref kAliHLTDataTypeESDTree|kAliHLTDataOriginTPC <br>
+ * Input Data Types: @ref kAliHLTDataTypeTObjArray|kAliHLTDataOriginTPC <br>
  * Output Data Types: @ref AliHLTTPCDefinitions::fgkOfflineCalibAlignDataType|kAliHLTDataOriginTPC <br>
  * Output Data Types: @ref AliHLTTPCDefinitions::fgkOfflineCalibTracksDataType|kAliHLTDataOriginTPC <br>
  * Output Data Types: @ref AliHLTTPCDefinitions::fgkOfflineCalibTracksGainDataType|kAliHLTDataOriginTPC <br>
diff --git a/HLT/TPCLib/offline/AliHLTTPCOfflineTrackerCalibComponent.cxx b/HLT/TPCLib/offline/AliHLTTPCOfflineTrackerCalibComponent.cxx
new file mode 100644 (file)
index 0000000..b0af5de
--- /dev/null
@@ -0,0 +1,374 @@
+// $Id$
+
+//**************************************************************************
+//* This file is property of and copyright by the ALICE HLT Project        * 
+//* ALICE Experiment at CERN, All rights reserved.                         *
+//*                                                                        *
+//* Primary Authors: Jacek Otwinowski <J.Otwinowski@gsi.de>                *
+//*                                                                        *
+//* 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   AliHLTTPCOfflineTrackerCalibComponent.cxx
+    @author Jacek Otwinowski & Matthias Richter
+    @date   
+    @brief  Wrapper component to the TPC offline tracker (ONLY CALIBRATION)
+*/
+
+#include "AliHLTTPCOfflineTrackerCalibComponent.h"
+#include "TString.h"
+#include "TClonesArray.h"
+#include "TObjArray.h"
+#include "TObjString.h"
+#include "AliVParticle.h"
+#include "AliCDBManager.h"
+#include "AliCDBEntry.h"
+#include "AliGeomManager.h"
+#include "AliMagFMaps.h"
+#include "AliTPCReconstructor.h"
+#include "AliTPCParam.h"
+#include "AliTPCRecoParam.h"
+#include "AliTPCParamSR.h"
+#include "AliTPCtrackerMI.h"
+#include "AliTPCClustersRow.h"
+#include "AliTPCseed.h"
+#include "AliESDEvent.h"
+#include "AliHLTTPCDefinitions.h"
+
+/** ROOT macro for the implementation of ROOT specific class methods */
+ClassImp(AliHLTTPCOfflineTrackerCalibComponent)
+
+AliHLTTPCOfflineTrackerCalibComponent::AliHLTTPCOfflineTrackerCalibComponent() : AliHLTProcessor(),
+fGeometryFileName(""),
+fTPCGeomParam(0),
+fTracker(0),
+fESD(0)
+{
+  // Default constructor
+  fGeometryFileName = getenv("ALICE_ROOT");
+  fGeometryFileName += "/HLT/TPCLib/offline/geometry.root";
+}
+
+AliHLTTPCOfflineTrackerCalibComponent::~AliHLTTPCOfflineTrackerCalibComponent()
+{
+  // see header file for class documentation
+}
+
+const char* AliHLTTPCOfflineTrackerCalibComponent::GetComponentID()
+{
+  // see header file for class documentation
+  return "TPCOfflineTrackerCalib";
+}
+
+void AliHLTTPCOfflineTrackerCalibComponent::GetInputDataTypes( vector<AliHLTComponentDataType>& list)
+{
+  // get input data type
+  list.push_back(kAliHLTDataTypeTObjArray|kAliHLTDataOriginTPC/*AliHLTTPCDefinitions::fgkOfflineClustersDataType*/);
+}
+
+AliHLTComponentDataType AliHLTTPCOfflineTrackerCalibComponent::GetOutputDataType()
+{
+  // create output data type
+  //return kAliHLTDataTypeESDObject|kAliHLTDataOriginTPC/*AliHLTTPCDefinitions::fgkOfflineTrackSegmentsDataType*/;
+  return kAliHLTDataTypeTObjArray|kAliHLTDataOriginTPC;
+}
+
+void AliHLTTPCOfflineTrackerCalibComponent::GetOutputDataSize(unsigned long& constBase, double& inputMultiplier)
+{
+  // get output data size
+  constBase = 2000000;
+  inputMultiplier = 1;
+}
+
+AliHLTComponent* AliHLTTPCOfflineTrackerCalibComponent::Spawn()
+{
+  // create instance of the component
+  return new AliHLTTPCOfflineTrackerCalibComponent;
+}
+
+int AliHLTTPCOfflineTrackerCalibComponent::DoInit( int argc, const char** argv )
+{
+  // init configuration 
+  //
+  int iResult=0;
+#ifdef HAVE_NOT_TPCOFFLINE_REC
+  HLTFatal("AliRoot version > v4-13-Release required");
+  return -ENOSYS;
+#endif
+
+  TString argument="";
+  TString configuration=""; 
+  int bMissingParam=0;
+
+  // loop over input parameters
+  for (int i=0; i<argc && iResult>=0; i++) {
+    argument=argv[i];
+    if (argument.IsNull()) continue;
+
+    if (argument.CompareTo("-geometry")==0) {
+      if ((bMissingParam=(++i>=argc))) break;
+
+      HLTInfo("got \'-geometry\' argument: %s", argv[i]);
+      fGeometryFileName = argv[i];
+      HLTInfo("Geometry file is: %s", fGeometryFileName.c_str());
+
+      // the remaining arguments are treated as configuration
+    } else {
+      if (!configuration.IsNull()) configuration+=" ";
+      configuration+=argument;
+    }
+  } // end loop
+
+  if (bMissingParam) {
+    HLTError("missing parameter for argument %s", argument.Data());
+    iResult=-EINVAL;
+  }
+
+  if (iResult>=0 && !configuration.IsNull()) {
+    iResult=Configure(configuration.Data());
+  } else {
+    iResult=Reconfigure(NULL, NULL);
+  }
+
+  //
+  // initialisation
+  //
+  // Load geometry
+  AliGeomManager::LoadGeometry(fGeometryFileName.c_str());
+  if((AliGeomManager::GetGeometry()) == 0) {
+    HLTError("Cannot load geometry from file %s",fGeometryFileName.c_str());
+    iResult=-EINVAL;
+  }
+
+  // TPC reconstruction parameters
+  AliTPCRecoParam * tpcRecoParam = AliTPCRecoParam::GetHLTParam();
+  if(tpcRecoParam) {
+    tpcRecoParam->SetClusterSharing(kTRUE);
+
+    AliTPCReconstructor tpcReconstructor;
+    tpcReconstructor.SetRecoParam(tpcRecoParam);
+  }
+  // TPC geometry parameters
+  fTPCGeomParam = new AliTPCParamSR;
+  if (fTPCGeomParam) {
+    fTPCGeomParam->ReadGeoMatrices();
+  }
+
+  // Init tracker
+  fTracker = new AliTPCtrackerMI(fTPCGeomParam);
+
+  // AliESDEvent event needed by AliTPCtrackerMI
+  // output of the component
+  fESD = new AliESDEvent();
+  if (fESD) {
+    fESD->CreateStdContent();
+  }
+
+  if (!fTracker || !fESD || !fTPCGeomParam) {
+    HLTError("failed creating internal objects");
+    iResult=-ENOMEM;
+  }
+
+  if (iResult>=0) {
+    // read the default CDB entries
+    iResult=Reconfigure(NULL, NULL);
+  }
+
+  return iResult;
+}
+
+int AliHLTTPCOfflineTrackerCalibComponent::DoDeinit()
+{
+  // deinit configuration
+
+  if(fTPCGeomParam) delete fTPCGeomParam; fTPCGeomParam = 0; 
+  if(fTracker) delete fTracker; fTracker = 0; 
+  if(fESD) delete fESD; fESD = 0;
+
+  return 0;
+}
+
+int AliHLTTPCOfflineTrackerCalibComponent::DoEvent( const AliHLTComponentEventData& /*evtData*/, AliHLTComponentTriggerData& /*trigData*/)
+{
+  // tracker function
+  HLTInfo("DoEvent processing data");
+
+  int iResult=0;
+  TClonesArray *clusterArray=0;
+  TObjArray *seedArray=0;
+  int slice, patch;
+
+  const AliHLTComponentBlockData* pBlock=GetFirstInputBlock(kAliHLTDataTypeTObjArray|kAliHLTDataOriginTPC); 
+  if(!pBlock) {
+     HLTError("Cannot get first data block 0x%08x ",pBlock);
+     iResult=-ENOMEM; return iResult;
+  }
+  int minSlice=AliHLTTPCDefinitions::GetMinSliceNr(pBlock->fSpecification);
+  int maxSlice=AliHLTTPCDefinitions::GetMaxSliceNr(pBlock->fSpecification);
+  int minPatch=AliHLTTPCDefinitions::GetMinPatchNr(pBlock->fSpecification);
+  int maxPatch=AliHLTTPCDefinitions::GetMaxPatchNr(pBlock->fSpecification);  
+
+  if (fTracker && fESD) {
+      // loop over input data blocks: TClonesArrays of clusters
+      for (TObject *pObj = (TObject *)GetFirstInputObject(kAliHLTDataTypeTObjArray|kAliHLTDataOriginTPC/*AliHLTTPCDefinitions::fgkOfflineClustersDataType*/,"TClonesArray",0);
+        pObj !=0 && iResult>=0;
+        pObj = (TObject *)GetNextInputObject(0)) {
+      clusterArray = dynamic_cast<TClonesArray*>(pObj);
+      if (!clusterArray) continue;
+
+      HLTInfo("load %d clusters from block %s 0x%08x", clusterArray->GetEntries(), DataType2Text(GetDataType(pObj)).c_str(), GetSpecification(pObj));
+      slice=AliHLTTPCDefinitions::GetMinSliceNr(GetSpecification(pObj));
+      patch=AliHLTTPCDefinitions::GetMinPatchNr(GetSpecification(pObj));
+
+      if(slice < minSlice) minSlice=slice;
+      if(slice > maxSlice) maxSlice=slice;
+      if(patch < minPatch) minPatch=patch;
+      if(patch > maxPatch) maxPatch=patch;
+#ifndef HAVE_NOT_TPCOFFLINE_REC
+      fTracker->LoadClusters(clusterArray);
+#endif //HAVE_NOT_TPCOFFLINE_REC
+    clusterArray->Delete();
+    }// end loop over input objects
+
+#ifndef HAVE_NOT_TPCOFFLINE_REC
+    // Load outer sectors
+      fTracker->LoadOuterSectors();
+    // Load inner sectors
+      fTracker->LoadInnerSectors();
+#endif
+
+    // set magnetic field for the ESD, assumes correct initialization of
+    // the field map
+    fESD->SetMagneticField(AliTracker::GetBz());
+  
+    // run tracker
+    fTracker->Clusters2Tracks(fESD);
+
+    // get TPC seeds
+    seedArray = fTracker->GetSeeds();
+
+    Int_t nTracks = fESD->GetNumberOfTracks();
+    HLTInfo("Number TPC tracks %d", nTracks);
+
+    // calculate specification from the specification of input data blocks
+    AliHLTUInt32_t iSpecification = AliHLTTPCDefinitions::EncodeDataSpecification( minSlice, maxSlice, minPatch, maxPatch );
+    HLTInfo("minSlice %d, maxSlice %d, minPatch %d, maxPatch %d", minSlice, maxSlice, minPatch, maxPatch);
+
+    // send data
+    if(seedArray) PushBack(seedArray, kAliHLTDataTypeTObjArray|kAliHLTDataOriginTPC, iSpecification);
+
+    // delete seeds
+    if(seedArray) seedArray->Delete();
+
+    // unload clusters
+    fTracker->UnloadClusters();
+
+    // reset ESDs and ESDs friends
+    fESD->Reset();
+
+  } else {
+    HLTError("component not initialized");
+    iResult=-ENOMEM;
+  }
+
+  return iResult;
+}
+
+int AliHLTTPCOfflineTrackerCalibComponent::Configure(const char* arguments)
+{
+  // see header file for class documentation
+  int iResult=0;
+  if (!arguments) return iResult;
+
+  TString allArgs=arguments;
+  TString argument;
+  int bMissingParam=0;
+
+  TObjArray* pTokens=allArgs.Tokenize(" ");
+  if (pTokens) {
+    for (int i=0; i<pTokens->GetEntries() && iResult>=0; i++) {
+      argument=((TObjString*)pTokens->At(i))->GetString();
+      if (argument.IsNull()) continue;
+
+      if (argument.CompareTo("-solenoidBz")==0) {
+       if ((bMissingParam=(++i>=pTokens->GetEntries()))) break;
+       // TODO: check if there is common functionality in the AliMagF* classes
+       float SolenoidBz=((TObjString*)pTokens->At(i))->GetString().Atof();
+       if (SolenoidBz<kAlmost0Field) SolenoidBz=kAlmost0Field;
+       float factor=1.;
+       int map=AliMagFMaps::k2kG;
+       if (SolenoidBz<3.) {
+         map=AliMagFMaps::k2kG;
+         factor=SolenoidBz/2;
+       } else if (SolenoidBz>=3. && SolenoidBz<4.5) {
+         map=AliMagFMaps::k4kG;
+         factor=SolenoidBz/4;
+       } else {
+         map=AliMagFMaps::k5kG;
+         factor=SolenoidBz/5;
+       }
+       // the magnetic field map is not supposed to change
+       // field initialization should be done once in the beginning
+       // TODO: does the factor need adjustment?
+       const AliMagF* currentMap=AliTracker::GetFieldMap();
+       if (!currentMap) {
+         AliMagFMaps* field = new AliMagFMaps("Maps","Maps", 2, 1., 10., map);
+         AliTracker::SetFieldMap(field,kFALSE);
+         HLTInfo("Solenoid Field set to: %f map %d", SolenoidBz, map);
+       } else if (currentMap->Map()!=map) {
+         HLTWarning("omitting request to override field map %s with %s", currentMap->Map(), map);
+       }
+       continue;
+      } else {
+       HLTError("unknown argument %s", argument.Data());
+       iResult=-EINVAL;
+       break;
+      }
+    }
+    delete pTokens;
+  }
+  if (bMissingParam) {
+    HLTError("missing parameter for argument %s", argument.Data());
+    iResult=-EINVAL;
+  }
+  return iResult;
+}
+
+int AliHLTTPCOfflineTrackerCalibComponent::Reconfigure(const char* cdbEntry, const char* chainId)
+{
+  // see header file for class documentation
+  int iResult=0;
+  const char* path=kAliHLTCDBSolenoidBz;
+  const char* defaultNotify="";
+  if (cdbEntry) {
+    path=cdbEntry;
+    defaultNotify=" (default)";
+  }
+  if (path) {
+    if (chainId) {} // just to get rid of warning, can not comment argument due to debug message
+    HLTDebug("reconfigure from entry %s%s, chain id %s", path, defaultNotify,(chainId!=NULL && chainId[0]!=0)?chainId:"<none>");
+    AliCDBEntry *pEntry = AliCDBManager::Instance()->Get(path/*,GetRunNo()*/);
+    if (pEntry) {
+      TObjString* pString=dynamic_cast<TObjString*>(pEntry->GetObject());
+      if (pString) {
+       HLTDebug("received configuration object string: \'%s\'", pString->GetString().Data());
+       iResult=Configure(pString->GetString().Data());
+      } else {
+       HLTError("configuration object \"%s\" has wrong type, required TObjString", path);
+      }
+    } else {
+      HLTError("can not fetch object \"%s\" from CDB", path);
+    }
+  }
+  
+  return iResult;
+}
diff --git a/HLT/TPCLib/offline/AliHLTTPCOfflineTrackerCalibComponent.h b/HLT/TPCLib/offline/AliHLTTPCOfflineTrackerCalibComponent.h
new file mode 100644 (file)
index 0000000..a22e8fa
--- /dev/null
@@ -0,0 +1,105 @@
+//-*- Mode: C++ -*-
+// $Id$
+#ifndef ALIHLTTPCOFFLINETRACKERCALIBCOMPONENT_H
+#define ALIHLTTPCOFFLINETRACKERCALIBCOMPONENT_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   AliHLTTPCOfflineTrackerCalibComponent.h
+    @author Jacek Otwinowski & Matthias Richter
+    @date   
+    @brief  Wrapper component to the TPC offline tracker (ONLY CALIBRATION)
+*/
+
+#include "AliHLTProcessor.h"
+
+/**
+ * @class AliHLTTPCOfflineTrackerCalibComponent
+ * Wrapper component to a TPC offline tracker for calibration
+ *
+ * The component interfaces the AliTPCtrackerMI of the TPC offline code
+ * to the online HLT (ONLY FOR CALIBRATION). The component expects a TClonesArray containing the
+ * cluster information. The output are TPC seed in TObjArray.
+ *
+ * <h2>General properties:</h2>
+ *
+ * Component ID: \b TPCOfflineTrackerCalib <br>
+ * Library: \b libAliHLTTPC.so     <br>
+ * Input Data Types: @ref kAliHLTDataTypeAliTObjArray|kAliHLTDataOriginTPC <br>
+ * Output Data Types: @ref kAliHLTDataTypeTObjArray|kAliHLTDataOriginTPC <br>
+ *
+ * <h2>Mandatory arguments:</h2>
+ * <!-- NOTE: ignore the \li. <i> and </i>: it's just doxygen formatting -->
+ *
+ * <h2>Optional arguments:</h2>
+ * <!-- NOTE: ignore the \li. <i> and </i>: it's just doxygen formatting -->
+ *
+ * <h2>Configuration:</h2>
+ * <!-- NOTE: ignore the \li. <i> and </i>: it's just doxygen formatting -->
+ *
+ * <h2>Default CDB entries:</h2>
+ * - loads magnetic field value from <tt>HLT/ConfigHLT/SolenoidBz</tt>.
+ *
+ * <h2>Performance:</h2>
+ * To be determined.
+ *
+ * <h2>Memory consumption:</h2>
+ * To be determined.
+ *
+ * <h2>Output size:</h2>
+ * To be determined.
+ *
+ * @ingroup alihlt_tpc_components
+ */
+
+class AliTPCParam;
+class AliTPCtrackerMI;
+class AliESDEvent;
+
+class AliHLTTPCOfflineTrackerCalibComponent : public AliHLTProcessor {
+public:
+  AliHLTTPCOfflineTrackerCalibComponent();
+  virtual ~AliHLTTPCOfflineTrackerCalibComponent();
+
+  // AliHLTComponent interface functions
+  const char* GetComponentID();
+  void GetInputDataTypes( vector<AliHLTComponentDataType>& list);
+  AliHLTComponentDataType GetOutputDataType();
+  void GetOutputDataSize( unsigned long& constBase, double& inputMultiplier );
+
+  // Spawn function, return new class instance
+  AliHLTComponent* Spawn();
+
+ protected:
+  // AliHLTComponent interface functions
+  int DoInit( int argc, const char** argv );
+  int DoDeinit();
+  int DoEvent( const AliHLTComponentEventData& evtData, AliHLTComponentTriggerData& trigData);
+  int Reconfigure(const char* cdbEntry, const char* chainId);
+
+  using AliHLTProcessor::DoEvent;
+
+private:
+  /** copy constructor prohibited */
+  AliHLTTPCOfflineTrackerCalibComponent(const AliHLTTPCOfflineTrackerCalibComponent&);
+  /** assignment operator prohibited */
+  AliHLTTPCOfflineTrackerCalibComponent& operator=(const AliHLTTPCOfflineTrackerCalibComponent&);
+  
+  string fGeometryFileName;   //! Geometry file with full path
+  AliTPCParam *fTPCGeomParam; //! TPC geometry params
+
+  AliTPCtrackerMI *fTracker;  //! TPC tracker
+  AliESDEvent *fESD;          //! AliESDEvent needed by TPC tracker
+
+  /**
+   * Configure the component.
+   * Parse a string for the configuration arguments and set the component
+   * properties.
+   */
+  int Configure(const char* arguments);
+
+  ClassDef(AliHLTTPCOfflineTrackerCalibComponent, 0)
+};
+#endif
index 8ba1aa4..2c801c7 100644 (file)
@@ -39,7 +39,6 @@
 #include "AliTPCClustersRow.h"
 #include "AliTPCseed.h"
 #include "AliESDEvent.h"
-#include "AliESDfriend.h"
 #include "AliHLTTPCDefinitions.h"
 
 /** ROOT macro for the implementation of ROOT specific class methods */
@@ -49,8 +48,7 @@ AliHLTTPCOfflineTrackerComponent::AliHLTTPCOfflineTrackerComponent() : AliHLTPro
 fGeometryFileName(""),
 fTPCGeomParam(0),
 fTracker(0),
-fESD(0),
-fESDfriend(0)
+fESD(0)
 {
   // Default constructor
   fGeometryFileName = getenv("ALICE_ROOT");
@@ -171,10 +169,6 @@ int AliHLTTPCOfflineTrackerComponent::DoInit( int argc, const char** argv )
   fESD = new AliESDEvent();
   if (fESD) {
     fESD->CreateStdContent();
-
-    // add ESD friend
-    fESDfriend = new AliESDfriend();
-    if(fESDfriend) fESD->AddObject(fESDfriend);
   }
 
   if (!fTracker || !fESD || !fTPCGeomParam) {
@@ -197,7 +191,6 @@ int AliHLTTPCOfflineTrackerComponent::DoDeinit()
   if(fTPCGeomParam) delete fTPCGeomParam; fTPCGeomParam = 0; 
   if(fTracker) delete fTracker; fTracker = 0; 
   if(fESD) delete fESD; fESD = 0;
-  //Note: fESD is owner of fESDfriends
 
   return 0;
 }
@@ -209,7 +202,6 @@ int AliHLTTPCOfflineTrackerComponent::DoEvent( const AliHLTComponentEventData& /
 
   int iResult=0;
   TClonesArray *clusterArray=0;
-  TObjArray *seedArray=0;
   int slice, patch;
 
   const AliHLTComponentBlockData* pBlock=GetFirstInputBlock(kAliHLTDataTypeTObjArray|kAliHLTDataOriginTPC); 
@@ -259,38 +251,11 @@ int AliHLTTPCOfflineTrackerComponent::DoEvent( const AliHLTComponentEventData& /
     // run tracker
     fTracker->Clusters2Tracks(fESD);
 
-    // add TPC seed to the AliESDtrack
-    seedArray = fTracker->GetSeeds();
-    if(seedArray) {
-       Int_t nseed = seedArray->GetEntriesFast();
-       HLTInfo("Number TPC seeds %d",nseed);
-
-       for(Int_t i=0; i<nseed; ++i) {
-          AliTPCseed *seed = (AliTPCseed*)seedArray->UncheckedAt(i);
-          if(!seed) continue; 
-
-          //HLTInfo("TPC seed:  sec %d, row %d",seed->GetSector(), seed->GetRow());
-
-          AliESDtrack *esdtrack=fESD->GetTrack(i);
-          if(esdtrack) esdtrack->AddCalibObject((TObject*)seed);
-         else 
-            HLTInfo("Cannot add TPC seed to AliESDtrack %d", i);
-       }
-    seedArray->Clear();
-    }
-
-    // reset ESDs friends (no Reset function!)
-    fESDfriend->~AliESDfriend();
-    new (fESDfriend) AliESDfriend(); // Reset ...
-
-    // add ESDfriend to AliESDEvent
-    fESD->GetESDfriend(fESDfriend);
-
     // unload clusters
     fTracker->UnloadClusters();
 
     Int_t nTracks = fESD->GetNumberOfTracks();
-    HLTInfo("Number of tracks %d", nTracks);
+    HLTInfo("Number TPC tracks %d", nTracks);
 
     // calculate specification from the specification of input data blocks
     AliHLTUInt32_t iSpecification = AliHLTTPCDefinitions::EncodeDataSpecification( minSlice, maxSlice, minPatch, maxPatch );
index ffcc5ff..ed9e1d7 100644 (file)
  * Wrapper component to the TPC offline tracker.
  *
  * The component interfaces the AliTPCtrackerMI of the TPC offline code
- * to the online HLT. The component expects a full TreeR containing the
+ * to the online HLT.  The component expects a TClonesArray containing the
  * cluster information. The output is in ESD format.
  *
  * <h2>General properties:</h2>
  *
  * Component ID: \b TPCOfflineTracker <br>
  * Library: \b libAliHLTTPC.so     <br>
- * Input Data Types: @ref kAliHLTDataTypeAliTreeR|kAliHLTDataOriginTPC <br>
+ * Input Data Types: @ref kAliHLTDataTypeAliTObjArray|kAliHLTDataOriginTPC <br>
  * Output Data Types: @ref kAliHLTDataTypeESDTree|kAliHLTDataOriginTPC <br>
  *
  * <h2>Mandatory arguments:</h2>
@@ -57,7 +57,6 @@
 class AliTPCParam;
 class AliTPCtrackerMI;
 class AliESDEvent;
-class AliESDfriend;
 
 class AliHLTTPCOfflineTrackerComponent : public AliHLTProcessor {
 public:
@@ -93,7 +92,6 @@ private:
 
   AliTPCtrackerMI *fTracker;  //! TPC tracker
   AliESDEvent *fESD;          //! AliESDEvent needed by TPC tracker
-  AliESDfriend *fESDfriend;   //! AliESDEvent needed by TPC calibration component
 
   /**
    * Configure the component.
index 79ebefa..8f3d5f7 100644 (file)
@@ -25,6 +25,7 @@ CLASS_HDRS:=          AliHLTTPCTransform.h \
                offline/AliHLTTPCDigitPublisherComponent.h \
                offline/AliHLTTPCOfflineClustererComponent.h \
                offline/AliHLTTPCOfflineTrackerComponent.h \
+               offline/AliHLTTPCOfflineTrackerCalibComponent.h \
                offline/AliHLTTPCOfflineCalibrationComponent.h \
                offline/AliHLTTPCOfflineCluster.h \
                AliHLTTPCClusters.h \