TPCdEdx component has been created.
authorsgorbuno <sgorbuno@f7af4fe6-9843-0410-8265-dc069ae4e863>
Sat, 24 Oct 2009 04:02:15 +0000 (04:02 +0000)
committersgorbuno <sgorbuno@f7af4fe6-9843-0410-8265-dc069ae4e863>
Sat, 24 Oct 2009 04:02:15 +0000 (04:02 +0000)
input: merged tracks + all the clusters,
output: dEdx labels -> GlobalEsdConverter

The method: create an AliTPCseed and call the CookdEdx() method.

The speed of the component is 170 Hz. These are only dEdx calculations w/o data transfer.
It runs stable, the output looks reasonable

Some steering parameters could be provided.

GlobalEsdConverter was updated also.

HLT/BASE/AliHLTDataTypes.cxx
HLT/BASE/AliHLTDataTypes.h
HLT/TPCLib/AliHLTTPCAgent.cxx
HLT/TPCLib/AliHLTTPCdEdxComponent.cxx [new file with mode: 0644]
HLT/TPCLib/AliHLTTPCdEdxComponent.h [new file with mode: 0644]
HLT/global/AliHLTGlobalEsdConverterComponent.cxx
HLT/libAliHLTTPC.pkg

index 4119c0f..73b90cf 100644 (file)
@@ -192,6 +192,9 @@ const AliHLTComponentDataType fgkITSTracksDataType = AliHLTComponentDataTypeInit
 /** Container of HLT calorimeter clusters */
 const AliHLTComponentDataType kAliHLTDataTypeCaloCluster = AliHLTComponentDataTypeInitializer( "CALOCLU", kAliHLTDataOriginAny );
 
+/** Container of dEdx */
+const AliHLTComponentDataType kAliHLTDataTypedEdx = AliHLTComponentDataTypeInitializer( "DEDX    ", kAliHLTDataOriginAny );
+
 //////////////////////////////////////////////////////////////////////////
 //
 // Data origin variables, to be used with the operator|
index fc06e2c..943faed 100644 (file)
@@ -430,6 +430,13 @@ const int kAliHLTComponentDataTypefIDsize=8;
  */
 #define kAliHLTJetDataTypeID                  {'H','L','T','J','E','T','V','0'}
 
+/** dEdx  data
+ * Common data type for the dEdx 
+ * format depends on the origin (detector)
+ * @ingroup alihlt_component_datatypes
+ */
+# define kAliHLTdEdxDataTypeID {'D','E','D','X',' ',' ',' ',' '}
+
 using namespace std;
 
 extern "C" {
@@ -1030,6 +1037,11 @@ extern "C" {
    */  
   extern const AliHLTComponentDataType kAliHLTDataTypeCaloCluster; 
 
+  /** Container of dEdx
+   * @ingroup alihlt_component_datatypes
+   */
+  extern const AliHLTComponentDataType kAliHLTDataTypedEdx;
+
   //////////////////////////////////////////////////////////////////////////
   //
   // FXS subscriber meta information
index 775640e..44e1332 100644 (file)
@@ -50,6 +50,7 @@ AliHLTTPCAgent gAliHLTTPCAgent;
 #include "AliHLTTPCCATrackerComponent.h"
 #include "AliHLTTPCTrackMCMarkerComponent.h"
 #include "AliHLTTPCCAGlobalMergerComponent.h"
+#include "AliHLTTPCdEdxComponent.h"
 #include "AliHLTTPCGlobalMergerComponent.h"
 #include "AliHLTTPCSliceTrackerComponent.h"
 #include "AliHLTTPCVertexFinderComponent.h"
@@ -272,6 +273,7 @@ int AliHLTTPCAgent::RegisterComponents(AliHLTComponentHandler* pHandler) const
   pHandler->AddComponent(new AliHLTTPCCAGlobalMergerComponent);
   pHandler->AddComponent(new AliHLTTPCTrackMCMarkerComponent);
   pHandler->AddComponent(new AliHLTTPCGlobalMergerComponent);
+  pHandler->AddComponent(new AliHLTTPCdEdxComponent);
   pHandler->AddComponent(new AliHLTTPCSliceTrackerComponent);
   pHandler->AddComponent(new AliHLTTPCVertexFinderComponent);
   pHandler->AddComponent(new AliHLTTPCClusterFinderComponent(AliHLTTPCClusterFinderComponent::kClusterFinderPacked));
diff --git a/HLT/TPCLib/AliHLTTPCdEdxComponent.cxx b/HLT/TPCLib/AliHLTTPCdEdxComponent.cxx
new file mode 100644 (file)
index 0000000..0ae9f95
--- /dev/null
@@ -0,0 +1,499 @@
+// **************************************************************************
+// This file is property of and copyright by the ALICE HLT Project          *
+// ALICE Experiment at CERN, All rights reserved.                           *
+//                                                                          *
+// Primary Authors: Sergey Gorbunov <sergey.gorbunov@kip.uni-heidelberg.de> *
+//                  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   AliHLTTPCdEdxComponent.cxx
+///  @author Sergey Gorbunov <sergey.gorbunov@kip.uni-heidelberg.de>
+///  @date   June 2009
+///  @brief  An ITS tracker processing component for the HLT
+
+
+/////////////////////////////////////////////////////
+//                                                 //
+// dEdx calculation component for the HLT TPC       //
+//                                                 //
+/////////////////////////////////////////////////////
+
+#include "AliHLTTPCdEdxComponent.h"
+#include "TStopwatch.h"
+#include "TMath.h"
+#include "AliCDBEntry.h"
+#include "AliCDBManager.h"
+#include "TObjString.h"
+#include "TObjArray.h"
+#include "AliHLTDataTypes.h"
+#include "AliHLTExternalTrackParam.h"
+#include "AliHLTGlobalBarrelTrack.h"
+#include "AliHLTTPCTransform.h"
+#include "AliHLTTPCSpacePointData.h"
+#include "AliHLTTPCClusterDataFormat.h"
+#include "AliHLTTPCTrackletDataFormat.h"
+#include "AliHLTTPCDefinitions.h"
+#include "AliTPCseed.h"
+#include "AliTPCclusterMI.h"
+#include "TGeoGlobalMagField.h"
+#include "AliMagF.h"
+
+
+/** ROOT macro for the implementation of ROOT specific class methods */
+ClassImp( AliHLTTPCdEdxComponent )
+AliHLTTPCdEdxComponent::AliHLTTPCdEdxComponent()
+    :
+    fSolenoidBz( 0 ),
+    fStatTime( 0 ),
+    fStatNEvents( 0 )
+{
+  // see header file for class documentation
+  // or
+  // refer to README to build package
+  // or
+  // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
+  for( int i=0; i<fkNPatches; i++ ){
+    fPatchClusters[i] = 0;    
+    fNPatchClusters[i] = 0;    
+  }
+}
+
+AliHLTTPCdEdxComponent::AliHLTTPCdEdxComponent( const AliHLTTPCdEdxComponent& )
+    :
+    AliHLTProcessor(),
+    fSolenoidBz( 0 ),
+    fStatTime( 0 ),
+    fStatNEvents( 0 )
+{
+  // see header file for class documentation
+  HLTFatal( "copy constructor untested" );
+}
+
+AliHLTTPCdEdxComponent& AliHLTTPCdEdxComponent::operator=( const AliHLTTPCdEdxComponent& )
+{
+  // see header file for class documentation
+  HLTFatal( "assignment operator untested" );
+  for( int i=0; i<fkNPatches; i++ ){
+    fPatchClusters[i] = 0;    
+    fNPatchClusters[i] = 0;    
+  }
+  return *this;
+}
+
+AliHLTTPCdEdxComponent::~AliHLTTPCdEdxComponent()
+{
+  // see header file for class documentation
+  for( int i=0; i<fkNPatches; i++ ){
+    delete[] fPatchClusters[i];
+  }
+}
+
+//
+// Public functions to implement AliHLTComponent's interface.
+// These functions are required for the registration process
+//
+
+const char* AliHLTTPCdEdxComponent::GetComponentID()
+{
+  // see header file for class documentation
+  return "TPCdEdx";
+}
+
+void AliHLTTPCdEdxComponent::GetInputDataTypes( vector<AliHLTComponentDataType>& list )
+{
+  // see header file for class documentation
+  list.clear();
+  list.push_back( kAliHLTDataTypeTrack|kAliHLTDataOriginTPC );
+  list.push_back( AliHLTTPCDefinitions::fgkClustersDataType );
+}
+
+AliHLTComponentDataType AliHLTTPCdEdxComponent::GetOutputDataType()
+{
+  // see header file for class documentation  
+  return kAliHLTDataTypedEdx|kAliHLTDataOriginTPC;
+}
+
+void AliHLTTPCdEdxComponent::GetOutputDataSize( unsigned long& constBase, double& inputMultiplier )
+{
+  // define guess for the output data size
+  constBase = 200;       // minimum size
+  inputMultiplier = 0.1; // size relative to input
+}
+
+AliHLTComponent* AliHLTTPCdEdxComponent::Spawn()
+{
+  // see header file for class documentation
+  return new AliHLTTPCdEdxComponent;
+}
+
+void AliHLTTPCdEdxComponent::SetDefaultConfiguration()
+{
+  // Set default configuration for the CA tracker component
+  // Some parameters can be later overwritten from the OCDB
+
+  fSolenoidBz = -5.00668;
+  fStatTime = 0;
+  fStatNEvents = 0;
+}
+
+int AliHLTTPCdEdxComponent::ReadConfigurationString(  const char* arguments )
+{
+  // Set configuration parameters for the CA tracker component from the string
+
+  int iResult = 0;
+  if ( !arguments ) return iResult;
+
+  TString allArgs = arguments;
+  TString argument;
+  int bMissingParam = 0;
+
+  TObjArray* pTokens = allArgs.Tokenize( " " );
+
+  int nArgs =  pTokens ? pTokens->GetEntries() : 0;
+
+  for ( int i = 0; i < nArgs; i++ ) {
+    argument = ( ( TObjString* )pTokens->At( i ) )->GetString();
+    if ( argument.IsNull() ) continue;
+
+    if ( argument.CompareTo( "-solenoidBz" ) == 0 ) {
+      if ( ( bMissingParam = ( ++i >= pTokens->GetEntries() ) ) ) break;
+      fSolenoidBz = ( ( TObjString* )pTokens->At( i ) )->GetString().Atof();
+      HLTInfo( "Magnetic Field set to: %f", fSolenoidBz );
+      continue;
+    }
+
+    HLTError( "Unknown option \"%s\"", argument.Data() );
+    iResult = -EINVAL;
+  }
+  delete pTokens;
+
+  if ( bMissingParam ) {
+    HLTError( "Specifier missed for parameter \"%s\"", argument.Data() );
+    iResult = -EINVAL;
+  }
+
+  return iResult;
+}
+
+
+int AliHLTTPCdEdxComponent::ReadCDBEntry( const char* cdbEntry, const char* chainId )
+{
+  // see header file for class documentation
+
+  const char* defaultNotify = "";
+
+  if ( !cdbEntry ) {
+    return 0;// need to add the HLT/ConfigTPC/TPCdEdx directory to cdb SG!!!
+    cdbEntry = "HLT/ConfigTPC/TPCdEdx";
+    defaultNotify = " (default)";
+    chainId = 0;
+  }
+
+  HLTInfo( "configure from entry \"%s\"%s, chain id %s", cdbEntry, defaultNotify, ( chainId != NULL && chainId[0] != 0 ) ? chainId : "<none>" );
+  AliCDBEntry *pEntry = AliCDBManager::Instance()->Get( cdbEntry );//,GetRunNo());
+
+  if ( !pEntry ) {
+    HLTError( "cannot fetch object \"%s\" from CDB", cdbEntry );
+    return -EINVAL;
+  }
+  
+  TObjString* pString = dynamic_cast<TObjString*>( pEntry->GetObject() );
+  
+  if ( !pString ) {
+    HLTError( "configuration object \"%s\" has wrong type, required TObjString", cdbEntry );
+    return -EINVAL;
+  }
+
+  HLTInfo( "received configuration object string: \"%s\"", pString->GetString().Data() );
+
+  return  ReadConfigurationString( pString->GetString().Data() );
+}
+
+
+int AliHLTTPCdEdxComponent::Configure( const char* cdbEntry, const char* chainId, const char *commandLine )
+{
+  // Configure the component
+  // There are few levels of configuration,
+  // parameters which are set on one step can be overwritten on the next step
+
+  //* read hard-coded values
+
+  SetDefaultConfiguration();
+
+  //* read the default CDB entry
+
+  int iResult1 = ReadCDBEntry( NULL, chainId );
+
+  //* read magnetic field
+
+  int iResult2 = ReadCDBEntry( kAliHLTCDBSolenoidBz, chainId );
+
+  //* read the actual CDB entry if required
+
+  int iResult3 = ( cdbEntry ) ? ReadCDBEntry( cdbEntry, chainId ) : 0;
+
+  //* read extra parameters from input (if they are)
+
+  int iResult4 = 0;
+
+  if ( commandLine && commandLine[0] != '\0' ) {
+    HLTInfo( "received configuration string from HLT framework: \"%s\"", commandLine );
+    iResult4 = ReadConfigurationString( commandLine );
+  }
+
+  // Initialise the tracker here
+
+  return iResult1 ? iResult1 : ( iResult2 ? iResult2 : ( iResult3 ? iResult3 : iResult4 ) );
+}
+
+
+
+int AliHLTTPCdEdxComponent::DoInit( int argc, const char** argv )
+{
+  // Configure the component
+
+  TString arguments = "";
+  for ( int i = 0; i < argc; i++ ) {
+    if ( !arguments.IsNull() ) arguments += " ";
+    arguments += argv[i];
+  }
+
+  int ret = Configure( NULL, NULL, arguments.Data() );
+
+  // set field
+  if (!TGeoGlobalMagField::Instance()->IsLocked()) {
+    AliMagF* field = new AliMagF("Maps","Maps",1.,1.,AliMagF::k5kG);
+    field->SetFactorSol(1);
+    Double_t initialFieldStrengh=field->SolenoidField();
+    field->SetFactorSol(fSolenoidBz/initialFieldStrengh); 
+    TGeoGlobalMagField::Instance()->SetField(field);  
+  }
+  
+  //AliTPCTransform *transform = AliTPCcalibDB::Instance()->GetTransform();
+  //if( transform ){
+  //AliTPCRecoParam *reco = transform->GetCurrentRecoParam();
+  //if( ! reco ){
+  //reco = new AliTPCRecoParam;
+  //reco->SetUseTotalCharge(0);
+  //transform->SetCurrentRecoParam( reco );
+  //}
+
+  return ret;
+}
+
+
+int AliHLTTPCdEdxComponent::DoDeinit()
+{
+  // see header file for class documentation
+  return 0;
+}
+
+
+
+int AliHLTTPCdEdxComponent::Reconfigure( const char* cdbEntry, const char* chainId )
+{
+  // Reconfigure the component from OCDB .
+
+  return Configure( cdbEntry, chainId, NULL );
+}
+
+
+
+int AliHLTTPCdEdxComponent::DoEvent
+(
+  const AliHLTComponentEventData& evtData,
+  const AliHLTComponentBlockData* blocks,
+  AliHLTComponentTriggerData& /*trigData*/,
+  AliHLTUInt8_t* outputPtr,
+  AliHLTUInt32_t& size,
+  vector<AliHLTComponentBlockData>& outputBlocks )
+{
+  //* process the event
+
+  AliHLTUInt32_t maxBufferSize = size;
+  size = 0; // output size
+
+  if (!IsDataEvent()) return 0;
+
+  if ( evtData.fBlockCnt <= 0 ) {
+    HLTWarning( "no blocks in event" );
+    return 0;
+  }
+  if ( !outputPtr ) {
+    return -ENOSPC;
+  }
+
+  int iResult=0;
+
+  TStopwatch timer;
+
+  // Initialise the data pointers
+
+  for( int i=0; i<fkNPatches; i++ ){
+    delete[] fPatchClusters[i];    
+    fPatchClusters[i] = 0;
+    fNPatchClusters[i] = 0;    
+  }
+
+  int nBlocks = (int)evtData.fBlockCnt;
+
+  int nInputClusters = 0;
+  int nInputTracks = 0;
+
+  // first read all the clusters
+
+  for (int ndx=0; ndx<nBlocks && iResult>=0; ndx++) {
+    const AliHLTComponentBlockData* iter = blocks+ndx;
+    if ( iter->fDataType != AliHLTTPCDefinitions::fgkClustersDataType ) continue;
+    Int_t slice=AliHLTTPCDefinitions::GetMinSliceNr(iter->fSpecification);
+    Int_t patch=AliHLTTPCDefinitions::GetMinPatchNr(iter->fSpecification);
+    Int_t slicepatch=slice*6+patch;
+    if( slicepatch > fkNPatches ){
+      HLTWarning("Wrong header of TPC cluster data, slice %d, patch %d",
+                slice, patch );
+      continue;
+    }
+    AliHLTTPCClusterData* inPtrSP = ( AliHLTTPCClusterData* )( iter->fPtr );
+    nInputClusters += inPtrSP->fSpacePointCnt;
+
+    delete[] fPatchClusters[slicepatch];
+    fPatchClusters[slicepatch] = new AliTPCclusterMI[inPtrSP->fSpacePointCnt];
+    fNPatchClusters[slicepatch] = inPtrSP->fSpacePointCnt;
+    
+    // create  off-line clusters out of the HLT clusters
+    // todo: check which cluster information is really needed for the dEdx
+
+    for ( unsigned int i = 0; i < inPtrSP->fSpacePointCnt; i++ ) {
+      AliHLTTPCSpacePointData *chlt = &( inPtrSP->fSpacePoints[i] );
+      AliTPCclusterMI *c = fPatchClusters[slicepatch]+i;
+      c->SetX(chlt->fX);
+      c->SetY(chlt->fY);
+      c->SetZ(chlt->fZ);
+      c->SetSigmaY2(chlt->fSigmaY2);
+      c->SetSigmaYZ( 0 );
+      c->SetSigmaZ2(chlt->fSigmaZ2);
+      c->SetQ( chlt->fCharge );
+      c->SetMax( chlt->fQMax );
+      Int_t sector, row;
+      Float_t padtime[3]={0,chlt->fY,chlt->fZ};
+      AliHLTTPCTransform::Slice2Sector(slice,chlt->fPadRow, sector, row);
+      AliHLTTPCTransform::Local2Raw( padtime, sector, row);
+      c->SetDetector( sector );
+      c->SetRow( row );
+      c->SetPad( (Int_t) padtime[1] );
+      c->SetTimeBin( (Int_t) padtime[2] );
+    }
+  }
+
+
+  // loop over the input tracks: calculate dEdx and write output
+
+  unsigned int outSize = 0;
+  AliHLTFloat32_t *outPtr = ( AliHLTFloat32_t * )( outputPtr );
+
+  for (const AliHLTComponentBlockData* pBlock=GetFirstInputBlock(kAliHLTDataTypeTrack|kAliHLTDataOriginTPC);
+       pBlock!=NULL; pBlock=GetNextInputBlock()) {
+    
+    AliHLTComponentBlockData outBlock;
+    FillBlockData( outBlock );
+    outBlock.fOffset = outSize;
+    outBlock.fSize = 0;
+    outBlock.fDataType = kAliHLTDataTypedEdx|kAliHLTDataOriginTPC;
+    outBlock.fSpecification = pBlock->fSpecification;
+  
+    AliHLTTracksData* dataPtr = ( AliHLTTracksData* ) pBlock->fPtr;
+    int nTracks = dataPtr->fCount;
+    AliHLTExternalTrackParam* currTrack = dataPtr->fTracklets;
+    nInputTracks+=nTracks;
+
+    for( int itr=0; 
+        itr<nTracks && ( (AliHLTUInt8_t *)currTrack < ((AliHLTUInt8_t *) pBlock->fPtr)+pBlock->fSize); 
+        itr++ ){
+
+      // create an off-line track
+      AliHLTGlobalBarrelTrack gb(*currTrack);
+      AliTPCseed tTPC;
+      tTPC.Set( gb.GetX(), gb.GetAlpha(),
+               gb.GetParameter(), gb.GetCovariance() );
+
+      // set the clusters
+      
+      for( Int_t ic=0; ic<currTrack->fNPoints; ic++){      
+       UInt_t id = currTrack->fPointIDs[ic];
+       int iSlice = id>>25;
+       int iPatch = (id>>22)&0x7; 
+       int iCluster = id&0x3fffff;
+       if( iSlice<0 || iSlice>36 || iPatch<0 || iPatch>5 ){
+         HLTError("Corrupted TPC cluster Id: slice %d, patch %d, cluster %d",
+                  iSlice, iPatch,iCluster );
+         continue;
+       }
+       AliTPCclusterMI *patchClusters = fPatchClusters[iSlice*6 + iPatch];
+       if( !patchClusters ){
+         HLTError("Clusters are missed for slice %d, patch %d",
+                  iSlice, iPatch );
+         continue;
+       }
+       if( iCluster >= fNPatchClusters[iSlice*6 + iPatch] ){
+         HLTError("TPC slice %d, patch %d: ClusterID==%d >= N Cluaters==%d ",
+                  iSlice, iPatch,iCluster, fNPatchClusters[iSlice*6 + iPatch] );
+         continue;
+       }
+       AliTPCclusterMI *c = &(patchClusters[iCluster]);          
+       
+       int sec = c->GetDetector();
+       int row = c->GetRow();
+       if ( sec >= 36 ) {
+         row = row + AliHLTTPCTransform::GetNRowLow();
+       }
+       tTPC.SetClusterPointer( row, c );
+       
+       AliTPCTrackerPoint &point = *( tTPC.GetTrackPoint( row ) );
+       tTPC.Propagate( TMath::DegToRad()*(sec%18*20.+10.), fSolenoidBz, c->GetX() );
+       Double_t angle2 = tTPC.GetSnp()*tTPC.GetSnp();
+       angle2 = (angle2<1) ?TMath::Sqrt(angle2/(1-angle2)) :10.; 
+       point.SetAngleY( angle2 );
+       point.SetAngleZ( tTPC.GetTgl() );
+      }
+
+      // Cook dEdx
+
+      if( outSize+sizeof( AliHLTFloat32_t ) > maxBufferSize ){
+        HLTWarning( "Output buffer size %d exceed", maxBufferSize );
+        iResult = -ENOSPC;
+        break;
+      }
+     *outPtr = tTPC.CookdEdx( 0.02, 0.6 );      
+      outPtr++;
+      outSize+=sizeof( AliHLTFloat32_t );    
+      outBlock.fSize+=sizeof( AliHLTFloat32_t );  
+
+      unsigned int step = sizeof( AliHLTExternalTrackParam ) + currTrack->fNPoints * sizeof( unsigned int );
+      currTrack = ( AliHLTExternalTrackParam* )( (( Byte_t * )currTrack) + step );  
+    }
+    if( iResult<0 ) break;
+    outputBlocks.push_back( outBlock );    
+    size = outSize;
+  }
+
+  timer.Stop();
+  fStatTime += timer.RealTime();
+  fStatNEvents++;
+  
+  // Set log level to "Warning" for on-line system monitoring
+  int hz = ( int ) ( fStatTime > 1.e-10 ? fStatNEvents / fStatTime : 100000 );
+
+  HLTInfo( "TPCdEdx : %d clusters and %d tracks processed; average time %d Hz",
+          nInputClusters, nInputTracks, hz );
+  
+  return iResult;
+}
diff --git a/HLT/TPCLib/AliHLTTPCdEdxComponent.h b/HLT/TPCLib/AliHLTTPCdEdxComponent.h
new file mode 100644 (file)
index 0000000..a00059a
--- /dev/null
@@ -0,0 +1,98 @@
+//-*- Mode: C++ -*-
+// ************************************************************************
+// 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   AliHLTTPCdEdxComponent.h
+///  @author Sergey Gorbunov <sergey.gorbunov@kip.uni-heidelberg.de>
+///  @date   June 2009
+///  @brief  An ITS tracker processing component for the HLT
+
+#ifndef ALIHLTTPCDEDXCOMPONENT_H
+#define ALIHLTTPCDEDXCOMPONENT_H
+
+#include "AliHLTProcessor.h"
+#include "AliHLTDataTypes.h"
+class AliTPCclusterMI;
+
+/**
+ * @class AliHLTTPCdEdxComponent
+ * The dEdx calculator component for the HLT TPC
+ *
+ */
+class AliHLTTPCdEdxComponent : public AliHLTProcessor
+{
+public:
+  /** standard constructor */
+  AliHLTTPCdEdxComponent();
+  
+  /** dummy copy constructor, defined according to effective C++ style */
+  AliHLTTPCdEdxComponent( const AliHLTTPCdEdxComponent& );
+  
+  /** dummy assignment op, but defined according to effective C++ style */
+  AliHLTTPCdEdxComponent& operator=( const AliHLTTPCdEdxComponent& );
+  
+  /** standard destructor */
+  virtual ~AliHLTTPCdEdxComponent();
+
+  // Public functions to implement AliHLTComponent's interface.
+  // These functions are required for the registration process
+
+  /** @see component interface @ref AliHLTComponent::GetComponentID */
+  const char* GetComponentID() ;
+
+  /** @see component interface @ref AliHLTComponent::GetInputDataTypes */
+  void GetInputDataTypes( vector<AliHLTComponentDataType>& list )  ;
+
+  /** @see component interface @ref AliHLTComponent::GetOutputDataType */
+  AliHLTComponentDataType GetOutputDataType() ;
+  
+  /** @see component interface @ref AliHLTComponent::GetOutputDataSize */
+  virtual void GetOutputDataSize( unsigned long& constBase, double& inputMultiplier ) ;
+
+  /** @see component interface @ref AliHLTComponent::Spawn */
+  AliHLTComponent* Spawn() ;
+
+protected:
+
+  // Protected functions to implement AliHLTComponent's interface.
+  // These functions provide initialization as well as the actual processing
+  // capabilities of the component.
+
+  /** @see component interface @ref AliHLTComponent::DoInit */
+  int DoInit( int argc, const char** argv );
+
+  /** @see component interface @ref AliHLTComponent::DoDeinit */
+  int DoDeinit();
+
+  /** reconfigure **/
+  int Reconfigure( const char* cdbEntry, const char* chainId );
+
+  /** @see component interface @ref AliHLTProcessor::DoEvent */
+  int DoEvent( const AliHLTComponentEventData& evtData, const AliHLTComponentBlockData* blocks,
+              AliHLTComponentTriggerData& trigData, AliHLTUInt8_t* outputPtr,
+              AliHLTUInt32_t& size, vector<AliHLTComponentBlockData>& outputBlocks );
+
+  private:
+
+    /** magnetic field */
+    double fSolenoidBz;                                            // see above
+    double fStatTime; //* total time for DoEvent() [s]   
+    Long_t    fStatNEvents;  //* number of reconstructed events
+  static const Int_t fkNPatches = 36*6; // number of patches in TPC
+  AliTPCclusterMI *fPatchClusters[fkNPatches]; //! arrays of cluster data for each TPC patch
+  Int_t fNPatchClusters[fkNPatches]; //! N of clusters for each TPC patch
+
+    /** set configuration parameters **/
+    void SetDefaultConfiguration();
+    int ReadConfigurationString(  const char* arguments );
+    int ReadCDBEntry( const char* cdbEntry, const char* chainId );
+    int Configure( const char* cdbEntry, const char* chainId, const char *commandLine  );
+
+    ClassDef( AliHLTTPCdEdxComponent, 0 );
+
+};
+#endif
index 6f9d855..785b6b7 100644 (file)
@@ -46,6 +46,7 @@
 #include "AliHLTCaloClusterReader.h"
 #include "AliESDCaloCluster.h"
 #include "AliHLTVertexer.h"
+#include "AliTPCseed.h"
 
 /** ROOT macro for the implementation of ROOT specific class methods */
 ClassImp(AliHLTGlobalEsdConverterComponent)
@@ -150,6 +151,7 @@ void AliHLTGlobalEsdConverterComponent::GetInputDataTypes(AliHLTComponentDataTyp
   list.push_back(kAliHLTDataTypeTrack);
   list.push_back(kAliHLTDataTypeTrackMC);
   list.push_back(kAliHLTDataTypeCaloCluster);
+  list.push_back(kAliHLTDataTypedEdx );
 }
 
 AliHLTComponentDataType AliHLTGlobalEsdConverterComponent::GetOutputDataType()
@@ -306,6 +308,17 @@ int AliHLTGlobalEsdConverterComponent::ProcessBlocks(TTree* pTree, AliESDEvent*
     }
   }
 
+  // read dEdx information (if present)
+
+  AliHLTFloat32_t *dEdxTPC = 0; 
+  Int_t ndEdxTPC = 0;
+  for (const AliHLTComponentBlockData* pBlock=GetFirstInputBlock(kAliHLTDataTypedEdx|kAliHLTDataOriginTPC);
+       pBlock!=NULL; pBlock=GetNextInputBlock()) {
+    dEdxTPC = reinterpret_cast<AliHLTFloat32_t*>( pBlock->fPtr );
+    ndEdxTPC = pBlock->fSize / sizeof(AliHLTFloat32_t);
+    break;
+  }
+
   // convert the TPC tracks to ESD tracks
   for (const AliHLTComponentBlockData* pBlock=GetFirstInputBlock(kAliHLTDataTypeTrack|kAliHLTDataOriginTPC);
        pBlock!=NULL; pBlock=GetNextInputBlock()) {
@@ -339,7 +352,16 @@ int AliHLTGlobalEsdConverterComponent::ProcessBlocks(TTree* pTree, AliESDEvent*
        iotrack.UpdateTrackParams(&(*element),AliESDtrack::kTPCin);
        iotrack.UpdateTrackParams(&(*element),AliESDtrack::kTPCout);
        iotrack.SetTPCPoints(points);
-
+       if( element->TrackID()<ndEdxTPC ){
+         AliTPCseed s;
+         s.Set( element->GetX(), element->GetAlpha(),
+                element->GetParameter(), element->GetCovariance() );
+         s.SetdEdx( dEdxTPC[element->TrackID()] );
+         s.CookPID();
+         iotrack.SetTPCpid(s.TPCrPIDs() );
+       } else {
+         if( dEdxTPC ) HLTWarning("Wrong number of dEdx TPC labels");
+       }
        pESD->AddTrack(&iotrack);
        if (fVerbosity>0) element->Print();
       }
index d27593d..9900e86 100644 (file)
@@ -104,7 +104,8 @@ CLASS_HDRS:=        AliHLTTPCTransform.h \
                AliHLTTPCTrackDumpComponent.h \
                AliHLTTPCClusterDumpComponent.h \
                AliHLTTPCHWCFDataReverterComponent.h \
-               AliHLTTPCTrackMCMarkerComponent.h               
+               AliHLTTPCTrackMCMarkerComponent.h \
+               AliHLTTPCdEdxComponent.h