dNdPtAnalysisComponent added
authorsgorbuno <sgorbuno@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 29 Oct 2010 21:20:16 +0000 (21:20 +0000)
committersgorbuno <sgorbuno@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 29 Oct 2010 21:20:16 +0000 (21:20 +0000)
HLT/global/AliHLTGlobalAgent.cxx
HLT/global/physics/AliHLTdNdPtAnalysisComponent.cxx [new file with mode: 0644]
HLT/global/physics/AliHLTdNdPtAnalysisComponent.h [new file with mode: 0644]
HLT/libAliHLTGlobal.pkg

index 90d1860..d1b2307 100644 (file)
@@ -34,6 +34,7 @@
 #include "AliHLTGlobalVertexerComponent.h"
 #include "AliHLTGlobalOfflineVertexerComponent.h"
 #include "AliHLTV0HistoComponent.h"
+#include "AliHLTdNdPtAnalysisComponent.h"
 #include "AliHLTGlobalVertexerHistoComponent.h"
 #include "AliHLTGlobalHistoComponent.h"
 #include "AliHLTGlobalHistoCollector.h"
@@ -73,6 +74,7 @@ int AliHLTGlobalAgent::RegisterComponents(AliHLTComponentHandler* pHandler) cons
   pHandler->AddComponent(new AliHLTGlobalVertexerHistoComponent);
   pHandler->AddComponent(new AliHLTGlobalHistoComponent);
   pHandler->AddComponent(new AliHLTV0HistoComponent );
+  pHandler->AddComponent(new AliHLTdNdPtAnalysisComponent );
   pHandler->AddComponent(new AliHLTGlobalHistoCollector );
   pHandler->AddComponent(new AliHLTGlobalDCSPublisherComponent );
   return 0;
@@ -172,6 +174,8 @@ int AliHLTGlobalAgent::CreateConfigurations(AliHLTConfigurationHandler* pHandler
     HLTWarning("No inputs to global HLT Vertex histogram component found");
   }
   
+  pHandler->CreateConfiguration("GLOBAL-dNdPtAnalysis", "dNdPtAnalysis", "GLOBAL-esd-converter", "");
+
   return 0;
 }
 
@@ -183,7 +187,7 @@ const char* AliHLTGlobalAgent::GetReconstructionChains(AliRawReader* /*rawReader
     // reconstruction chains for AliRoot simulation
     // Note: run loader is only available while running embedded into
     // AliRoot simulation
-    return "GLOBAL-esd-converter";
+    return "GLOBAL-esd-converter";    
   }
   return NULL;
 }
@@ -192,7 +196,7 @@ const char* AliHLTGlobalAgent::GetRequiredComponentLibraries() const
 {
   // see header file for class documentation
 
-  return "";
+  return "libPWG0base.so libPWG0dep.so";
 }
 
 int AliHLTGlobalAgent::GetHandlerDescription(AliHLTComponentDataType /*dt*/,
diff --git a/HLT/global/physics/AliHLTdNdPtAnalysisComponent.cxx b/HLT/global/physics/AliHLTdNdPtAnalysisComponent.cxx
new file mode 100644 (file)
index 0000000..2ccc9ec
--- /dev/null
@@ -0,0 +1,470 @@
+//**************************************************************************
+//* This file is property of and copyright by the ALICE HLT Project        * 
+//* ALICE Experiment at CERN, All rights reserved.                         *
+//*                                                                        *
+//* Primary Authors: S.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   AliHLTdNdPtAnalysisComponent.cxx
+    @author Sergey Gorbunov
+    @brief  Component for ploting charge in clusters
+*/
+
+#if __GNUC__>= 3
+using namespace std;
+#endif
+
+#include "AliHLTdNdPtAnalysisComponent.h"
+#include "AlidNdPtAnalysisPbPb.h"
+#include "AlidNdPtEventCuts.h"
+#include "AlidNdPtAcceptanceCuts.h"
+#include "AliESDtrackCuts.h"
+
+#include "AliCDBEntry.h"
+#include "AliCDBManager.h"
+#include <TFile.h>
+#include <TString.h>
+#include "TObjString.h"
+#include "TObjArray.h"
+#include "TH1F.h"
+#include "TH2F.h"
+#include "TSystem.h"
+#include "AliESDEvent.h"
+#include "AliESDtrack.h"
+#include "AliESDv0.h"
+#include "AliHLTMessage.h"
+#include "TTimeStamp.h"
+
+//#include "AliHLTTPC.h"
+//#include <stdlib.h>
+//#include <cerrno>
+
+
+AliHLTdNdPtAnalysisComponent::AliHLTdNdPtAnalysisComponent() :
+  fUID(0),
+  fBenchmark("dNdPt"),
+  fAnalysis(0),
+  fEventCuts(0),
+  fAcceptanceCuts(0),
+  fESDtrackCuts(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
+
+}
+
+AliHLTdNdPtAnalysisComponent::~AliHLTdNdPtAnalysisComponent()
+{
+  // see header file for class documentation
+  if( fAnalysis ){
+    fAnalysis->SetEventCuts(0);
+    fAnalysis->SetAcceptanceCuts(0);
+    fAnalysis->SetTrackCuts(0);
+  }
+  delete fAnalysis;
+  delete fEventCuts;
+  delete fAcceptanceCuts;
+  delete fESDtrackCuts;
+}
+
+// Public functions to implement AliHLTComponent's interface.
+// These functions are required for the registration process
+
+const char* AliHLTdNdPtAnalysisComponent::GetComponentID()
+{
+  // see header file for class documentation
+  
+  return "dNdPtAnalysis";
+}
+
+void AliHLTdNdPtAnalysisComponent::GetInputDataTypes(AliHLTComponentDataTypeList& list)
+{
+  // see header file for class documentation
+  list.clear();
+  list.push_back( kAliHLTDataTypeESDObject|kAliHLTDataOriginOut );
+}
+
+AliHLTComponentDataType AliHLTdNdPtAnalysisComponent::GetOutputDataType()
+{
+  // see header file for class documentation
+  return kAliHLTDataTypeHistogram  | kAliHLTDataOriginOut;
+}
+
+void AliHLTdNdPtAnalysisComponent::GetOutputDataSize( unsigned long& constBase, double& inputMultiplier )
+{
+  // see header file for class documentation
+  // XXX TODO: Find more realistic values.
+  constBase = 80000;
+  inputMultiplier = 0;
+}
+
+AliHLTComponent* AliHLTdNdPtAnalysisComponent::Spawn()
+{
+  // see header file for class documentation
+  return new AliHLTdNdPtAnalysisComponent;
+}
+
+void AliHLTdNdPtAnalysisComponent::SetDefaultConfiguration()
+{
+  // Set default configuration for the CA merger component
+  // Some parameters can be later overwritten from the OCDB
+
+  fBenchmark.Reset();
+  fBenchmark.SetTimer(0,"total");
+  fBenchmark.SetTimer(1,"reco");    
+
+  if( !fEventCuts || !fAcceptanceCuts || !fESDtrackCuts){
+    HLTError("Out of memory");
+    return ;
+  }
+
+  Float_t zvWindow=20.;
+  float etaWindow=0.9;
+  Float_t ptMin=0.15;
+  
+  fEventCuts->SetZvRange(-zvWindow,zvWindow);  
+  fEventCuts->SetMeanXYZv(0.0,0.0,0.0);
+  fEventCuts->SetSigmaMeanXYZv(1.0,1.0,10.0);  
+  fEventCuts->SetTriggerRequired(kFALSE);
+
+  fAcceptanceCuts->SetEtaRange(-etaWindow,etaWindow);
+  fAcceptanceCuts->SetPtRange(ptMin,1.e10);
+  fAcceptanceCuts->SetMaxDCAr(3.0);
+  fAcceptanceCuts->SetMaxDCAz(30.0);
+
+  float maxDCAtoVertex = 3.0; // cm
+
+  fESDtrackCuts->SetRequireSigmaToVertex(kFALSE);
+  fESDtrackCuts->SetMaxDCAToVertexXY(maxDCAtoVertex);    
+  fESDtrackCuts->SetMaxDCAToVertexZ(maxDCAtoVertex);    
+  fESDtrackCuts->SetRequireTPCRefit(kFALSE);
+  fESDtrackCuts->SetAcceptKinkDaughters(kTRUE);
+  fESDtrackCuts->DefineHistograms();
+}
+
+
+
+int AliHLTdNdPtAnalysisComponent::ReadConfigurationString(  const char* arguments )
+{
+  // Set configuration parameters for the CA merger component from the string
+
+  int iResult = 0;
+  if ( !arguments ) return iResult;
+
+  if( !fEventCuts || !fAcceptanceCuts || !fESDtrackCuts){
+    HLTError("Out of memory");
+    return -ENOMEM;
+  }
+
+  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( "-vertexZRange" ) == 0 ) {
+      if ( ( bMissingParam = ( ++i >= pTokens->GetEntries() ) ) ) break;
+      float z = ( ( TObjString* )pTokens->At( i ) )->GetString().Atof();
+      fEventCuts->SetZvRange(-z, z );
+      HLTInfo( "Z vertex range is set to [%f,%f]", -z,z);
+      continue;
+    }
+    if ( argument.CompareTo( "-meanVertexXYZ" ) == 0 ) {
+      if ( ( bMissingParam = ( ++i >= pTokens->GetEntries() ) ) ) break;
+      float x = ( ( TObjString* )pTokens->At( i ) )->GetString().Atof();
+      if ( ( bMissingParam = ( ++i >= pTokens->GetEntries() ) ) ) break;
+      float y = ( ( TObjString* )pTokens->At( i ) )->GetString().Atof();
+      if ( ( bMissingParam = ( ++i >= pTokens->GetEntries() ) ) ) break;
+      float z = ( ( TObjString* )pTokens->At( i ) )->GetString().Atof();
+      fEventCuts->SetMeanXYZv(x,y,z);
+      HLTInfo( "mean vertex is set to (%f,%f,%f)", x,y,z);
+      continue;
+    }
+    if ( argument.CompareTo( "-meanVertexXYZSigma" ) == 0 ) {
+      if ( ( bMissingParam = ( ++i >= pTokens->GetEntries() ) ) ) break;
+      float x = ( ( TObjString* )pTokens->At( i ) )->GetString().Atof();
+      if ( ( bMissingParam = ( ++i >= pTokens->GetEntries() ) ) ) break;
+      float y = ( ( TObjString* )pTokens->At( i ) )->GetString().Atof();
+      if ( ( bMissingParam = ( ++i >= pTokens->GetEntries() ) ) ) break;
+      float z = ( ( TObjString* )pTokens->At( i ) )->GetString().Atof();
+      fEventCuts->SetSigmaMeanXYZv(x,y,z);
+      HLTInfo( "mean vertex sigma is set to (%f,%f,%f)", x,y,z);
+      continue;
+    }
+
+    if ( argument.CompareTo( "-etaRange" ) == 0 ) {
+      if ( ( bMissingParam = ( ++i >= pTokens->GetEntries() ) ) ) break;
+      float eta = ( ( TObjString* )pTokens->At( i ) )->GetString().Atof();
+      fAcceptanceCuts->SetEtaRange(-eta,eta);     
+      HLTInfo( "eta range is set to [%f,%f]", -eta,eta);
+      continue;
+    }
+
+    if ( argument.CompareTo( "-ptRange" ) == 0 ) {
+      if ( ( bMissingParam = ( ++i >= pTokens->GetEntries() ) ) ) break;
+      float ptMin = ( ( TObjString* )pTokens->At( i ) )->GetString().Atof();
+      if ( ( bMissingParam = ( ++i >= pTokens->GetEntries() ) ) ) break;
+      float ptMax = ( ( TObjString* )pTokens->At( i ) )->GetString().Atof();
+      fAcceptanceCuts->SetPtRange(ptMin,1.e10);
+      HLTInfo( "pt range is set to [%f,%f]", -ptMin,ptMax);
+      continue;
+    }
+    if ( argument.CompareTo( "-dcaRmax" ) == 0 ) {
+      if ( ( bMissingParam = ( ++i >= pTokens->GetEntries() ) ) ) break;
+      float x = ( ( TObjString* )pTokens->At( i ) )->GetString().Atof();
+      fAcceptanceCuts->SetMaxDCAr(x);
+      HLTInfo( "max DCA R is set to %f", x);
+      continue;
+    }
+    if ( argument.CompareTo( "-dcaZmax" ) == 0 ) {
+      if ( ( bMissingParam = ( ++i >= pTokens->GetEntries() ) ) ) break;
+      float x = ( ( TObjString* )pTokens->At( i ) )->GetString().Atof();
+      fAcceptanceCuts->SetMaxDCAz(x);
+      HLTInfo( "max DCA Z is set to %f", x);
+      continue;
+    }
+
+    if ( argument.CompareTo( "-dcaVtxRmax" ) == 0 ) {
+      if ( ( bMissingParam = ( ++i >= pTokens->GetEntries() ) ) ) break;
+      float x = ( ( TObjString* )pTokens->At( i ) )->GetString().Atof();
+      fESDtrackCuts->SetMaxDCAToVertexXY(x);    
+      HLTInfo( "max DCA R to vertex  is set to %f", x);
+      continue;
+    }
+
+    if ( argument.CompareTo( "-dcaVtxZmax" ) == 0 ) {
+      if ( ( bMissingParam = ( ++i >= pTokens->GetEntries() ) ) ) break;
+      float x = ( ( TObjString* )pTokens->At( i ) )->GetString().Atof();
+      fESDtrackCuts->SetMaxDCAToVertexZ(x);    
+      HLTInfo( "max DCA Z to vertex  is set to %f", x);
+      continue;
+    }
+
+    if ( argument.CompareTo( "-sigmaToVertex" ) == 0 ) {
+      if ( ( bMissingParam = ( ++i >= pTokens->GetEntries() ) ) ) break;
+      bool x = ( ( TObjString* )pTokens->At( i ) )->GetString().Atoi();
+      fESDtrackCuts->SetRequireSigmaToVertex(x);
+      HLTInfo( "sigma to vertex requirement is set to %i",x);
+      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 AliHLTdNdPtAnalysisComponent::ReadCDBEntry( const char* cdbEntry, const char* chainId )
+{
+  // see header file for class documentation
+  return 0;//SG!!!
+  const char* defaultNotify = "";
+  
+  if ( !cdbEntry ) {
+    cdbEntry = ""; 
+    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 AliHLTdNdPtAnalysisComponent::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
+
+  if( !fEventCuts ) fEventCuts = new AlidNdPtEventCuts;
+  if( !fAcceptanceCuts ) fAcceptanceCuts = new AlidNdPtAcceptanceCuts;
+  if( !fESDtrackCuts ) fESDtrackCuts = new AliESDtrackCuts;
+
+  if( !fEventCuts || !fAcceptanceCuts || !fESDtrackCuts){
+    HLTError("Out of memory");
+    return -ENOMEM;
+  }
+
+  //* read hard-coded values
+
+  SetDefaultConfiguration();
+
+  //* read the default CDB entry
+
+  int iResult1 = ReadCDBEntry( NULL, chainId );
+
+  //* read the actual CDB entry if required
+
+  int iResult2 = ( cdbEntry ) ? ReadCDBEntry( cdbEntry, chainId ) : 0;
+
+  //* read extra parameters from input (if they are)
+
+  int iResult3 = 0;
+
+  if ( commandLine && commandLine[0] != '\0' ) {
+    HLTInfo( "received configuration string from HLT framework: \"%s\"", commandLine );
+    iResult3 = ReadConfigurationString( commandLine );
+  }
+
+  return iResult1 ? iResult1 : ( iResult2 ? iResult2 : iResult3 );
+}
+
+int AliHLTdNdPtAnalysisComponent::Reconfigure( const char* cdbEntry, const char* chainId )
+{
+  // Reconfigure the component from OCDB
+
+  return Configure( cdbEntry, chainId, NULL );
+}
+
+
+int AliHLTdNdPtAnalysisComponent::DoInit( int argc, const char** argv ) 
+{
+  // init
+
+  fUID = 0;
+  fBenchmark.Reset();
+  fBenchmark.SetTimer(0,"total");
+  fBenchmark.SetTimer(1,"reco");
+
+  TString arguments = "";
+  for ( int i = 0; i < argc; i++ ) {
+    if ( !arguments.IsNull() ) arguments += " ";
+    arguments += argv[i];
+  }
+
+  int iResult = Configure( NULL, NULL, arguments.Data()  );
+
+  if( fAnalysis ){
+    fAnalysis->SetEventCuts(0);
+    fAnalysis->SetAcceptanceCuts(0);
+    fAnalysis->SetTrackCuts(0);
+  }
+  delete fAnalysis;  
+
+  fAnalysis = new AlidNdPtAnalysisPbPb;
+
+  if( !fAnalysis || !fEventCuts || !fAcceptanceCuts || !fESDtrackCuts){
+    HLTError("Out of memory");
+    return -ENOMEM;
+  }
+
+  fAnalysis->SetUseMCInfo(kFALSE);
+  fAnalysis->SetAnalysisMode(AlidNdPtHelper::kTPC);
+  fAnalysis->SetTrigger(AliTriggerAnalysis::kMB1);
+  fAnalysis->SetTriggerClass(0) ;
+  fAnalysis->SetParticleMode(AlidNdPtHelper::kAllPart);
+  fAnalysis->SetPhysicsTriggerSelection(0);
+
+  fAnalysis->SetEventCuts(fEventCuts);
+  fAnalysis->SetAcceptanceCuts(fAcceptanceCuts);
+  fAnalysis->SetTrackCuts(fESDtrackCuts);
+
+  fAnalysis->SetBackgroundCuts(0);
+  
+  fAnalysis->Init();
+
+  return iResult; 
+}
+  
+int AliHLTdNdPtAnalysisComponent::DoDeinit()
+{
+  // see header file for class documentation
+  fUID = 0;
+  if( fAnalysis ){
+    fAnalysis->SetEventCuts(0);
+    fAnalysis->SetAcceptanceCuts(0);
+    fAnalysis->SetTrackCuts(0);
+  }
+  delete fAnalysis;
+  fAnalysis = 0;
+  return 0;
+}
+
+
+int AliHLTdNdPtAnalysisComponent::DoEvent(const AliHLTComponentEventData& evtData, AliHLTComponentTriggerData& /*trigData*/)
+{
+  if ( GetFirstInputBlock( kAliHLTDataTypeSOR ) || GetFirstInputBlock( kAliHLTDataTypeEOR ) ) {
+    return 0;
+  }
+
+  if( !fAnalysis ){
+    HLTWarning("Analysis objects has not been created!!!");
+    return 0;
+  }
+
+  fBenchmark.StartNewEvent();
+  fBenchmark.Start(0);
+  
+
+  if( fUID == 0 ){
+    TTimeStamp t;
+    fUID = ( gSystem->GetPid() + t.GetNanoSec())*10 + evtData.fEventID;
+  }
+
+  for( const AliHLTComponentBlockData *i= GetFirstInputBlock(); i!=NULL; i=GetNextInputBlock() ){
+    fBenchmark.AddInput(i->fSize);
+  }
+
+  for ( const TObject *iter = GetFirstInputObject(kAliHLTDataTypeESDObject); iter != NULL; iter = GetNextInputObject() ) {
+
+    AliESDEvent *esdEvent = dynamic_cast<AliESDEvent*>(const_cast<TObject*>( iter ) );
+    if( !esdEvent ){ 
+      HLTWarning("Wrong ESDEvent object received");
+      continue;
+    }
+    esdEvent->GetStdContent();
+    fBenchmark.Start(1);
+    fAnalysis->Process(esdEvent);
+    fBenchmark.Stop(1);
+  }
+  fBenchmark.Stop(0);
+  HLTWarning(fBenchmark.GetStatistics());
+  return 0;
+}
+
+
diff --git a/HLT/global/physics/AliHLTdNdPtAnalysisComponent.h b/HLT/global/physics/AliHLTdNdPtAnalysisComponent.h
new file mode 100644 (file)
index 0000000..9541136
--- /dev/null
@@ -0,0 +1,88 @@
+#ifndef ALIHLTDNDPTANALYSISCOMPONENT_H
+#define ALIHLTDNDPTANALYSISCOMPONENT_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   AliHLTdNdPtAnalysisComponent.h
+    @author Sergey Gorbunov
+    @brief  Component for dNdPt analysis 
+*/
+
+#include "AliHLTProcessor.h"
+#include "AliHLTComponentBenchmark.h"
+
+class AlidNdPtEventCuts;
+class AlidNdPtAcceptanceCuts;
+class AliESDtrackCuts;
+class AlidNdPtAnalysisPbPb;
+
+
+/**
+ * @class AliHLTdNdPtAnalysisComponent
+ * Component for dNdPt analysis
+ */
+class AliHLTdNdPtAnalysisComponent : public AliHLTProcessor
+{
+public:
+  /** default constructor */
+  AliHLTdNdPtAnalysisComponent();
+  /** destructor */
+  virtual ~AliHLTdNdPtAnalysisComponent();
+
+  // Public functions to implement AliHLTComponent's interface.
+  // These functions are required for the registration process
+
+  /** interface function, see AliHLTComponent for description */
+  const char* GetComponentID();
+  /** interface function, see AliHLTComponent for description */
+  void GetInputDataTypes(AliHLTComponentDataTypeList& list);
+  /** interface function, see AliHLTComponent for description */
+  AliHLTComponentDataType GetOutputDataType();
+  /** interface function, see AliHLTComponent for description */
+  virtual void GetOutputDataSize( unsigned long& constBase, double& inputMultiplier );
+  /** interface function, see AliHLTComponent for description */
+  AliHLTComponent* Spawn();
+
+protected:
+
+  // Protected functions to implement AliHLTComponent's interface.
+  // These functions provide initialization as well as the actual processing
+  // capabilities of the component. 
+
+  /** interface function, see AliHLTComponent for description */
+  int DoInit( int argc, const char** argv );
+  /** interface function, see AliHLTComponent for description */
+  int DoDeinit();
+  /** interface function, see AliHLTComponent for description */
+  int DoEvent( const AliHLTComponentEventData& /*evtData*/, AliHLTComponentTriggerData& trigData );
+
+  int Reconfigure(const char* cdbEntry, const char* chainId);
+
+  using AliHLTProcessor::DoEvent;
+  
+private:
+  /** copy constructor prohibited */
+  AliHLTdNdPtAnalysisComponent(const AliHLTdNdPtAnalysisComponent&);
+  /** assignment operator prohibited */
+  AliHLTdNdPtAnalysisComponent& operator=(const AliHLTdNdPtAnalysisComponent&);
+  /**
+   * Configure the component.
+   * Parse a string for the configuration arguments and set the component
+   * properties.
+   */ 
+  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 );
+
+  
+  AliHLTUInt32_t fUID;// uID of the component
+  AliHLTComponentBenchmark fBenchmark; // benchmarks
+  AlidNdPtAnalysisPbPb *fAnalysis; // analysis object
+  AlidNdPtEventCuts *fEventCuts;  
+  AlidNdPtAcceptanceCuts *fAcceptanceCuts;
+  AliESDtrackCuts *fESDtrackCuts;
+
+};
+#endif
index 016860b..f325303 100644 (file)
@@ -19,8 +19,8 @@ CLASS_HDRS:=  AliHLTGlobalEsdConverterComponent.h \
                physics/AliHLTCaloHistoInvMass.h \
                physics/AliHLTCaloHistoMatchedTracks.h \
                physics/AliHLTCaloHistoClusterEnergy.h \
-               physics/AliHLTCaloHistoCellEnergy.h 
-
+               physics/AliHLTCaloHistoCellEnergy.h \
+               physics/AliHLTdNdPtAnalysisComponent.h
 #//
 
 MODULE_SRCS=   $(CLASS_HDRS:.h=.cxx)
@@ -36,11 +36,12 @@ EINCLUDE    := HLT/global HLT/global/physics \
                   RAW \
                   TRD \
                   STEER \
-                  PHOS
+                  PHOS \
+                  PWG0 PWG0/dNdPt 
 
 LIBRARY_DEP := -lHLTbase -lAliHLTUtil \
                -lCDB -lESD -lSTEER -lSTEERBase -lTPCrec -lTPCcalib -lTPCbase \
-               -lRAWDatarec -lRAWDatabase -lTRDbase \
+               -lRAWDatarec -lRAWDatabase -lTRDbase -lPWG0base -lPWG0dep \
                -L$(ROOTLIBDIR) -lEG
 
 ###############################################################################