[u/mrichter/AliRoot.git] / HLT / TPCLib / AliHLTTPCEventStatisticsProducerComponent.cxx

//-*- Mode: C++ -*-
// $Id$
/**************************************************************************
 * This file is property of and copyright by the ALICE HLT Project        * 
 * ALICE Experiment at CERN, All rights reserved.                         *
 *                                                                        *
 * Primary Authors: Jochen Thaeder <thaeder@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   AliHLTTPCEventStatisticsProducerComponent.cxx
    @author Jochen Thaeder
    @date   
    @brief  Component for the @see AliHLTTPCEventStatisticsProducer class
*/

// see header file for class documentation
// or
// refer to README to build package
// or
// visit http://web.ift.uib.no/~kjeks/doc/alice-hlt   

#if __GNUC__ >= 3
using namespace std;
#endif

#include "AliHLTTPCEventStatisticsProducerComponent.h"

#include "AliHLTTPCDefinitions.h"
#include "AliHLTTPCClusterDataFormat.h"
#include "AliHLTTPCTrackSegmentData.h"
#include "AliHLTTPCTrackletDataFormat.h"
#include "AliHLTTPCTrack.h"

#include "TMath.h"

#include <cerrno>

/** ROOT macro for the implementation of ROOT specific class methods */
ClassImp(AliHLTTPCEventStatisticsProducerComponent)
    
// ------------------------------------------------------------------------------------------
AliHLTTPCEventStatisticsProducerComponent::AliHLTTPCEventStatisticsProducerComponent() : 
  fClusterThreshold(0),
  fEvStat(NULL),
  fNTracksPerSlice(),
  fTracks(NULL),
  fGlobalTracks(kFALSE),
  fNSlice(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
}

// ------------------------------------------------------------------------------------------
AliHLTTPCEventStatisticsProducerComponent::~AliHLTTPCEventStatisticsProducerComponent() {
  // see header file for class documentation
}

// ------------------------------------------------------------------------------------------
const char* AliHLTTPCEventStatisticsProducerComponent::GetComponentID() {
  // see header file for class documentation
  return "TPCEventStatisticsProducer"; 
}

// ------------------------------------------------------------------------------------------
void AliHLTTPCEventStatisticsProducerComponent::GetInputDataTypes(AliHLTComponentDataTypeList& list) {
  // see header file for class documentation

  list.clear(); 
  list.push_back( AliHLTTPCDefinitions::fgkClustersDataType );
  list.push_back( AliHLTTPCDefinitions::fgkTracksDataType );
  list.push_back( AliHLTTPCDefinitions::fgkTrackSegmentsDataType );
}

// ------------------------------------------------------------------------------------------
AliHLTComponentDataType AliHLTTPCEventStatisticsProducerComponent::GetOutputDataType() {
  // see header file for class documentation

  return kAliHLTDataTypeEventStatistics|kAliHLTDataOriginTPC;
}

// ------------------------------------------------------------------------------------------
void AliHLTTPCEventStatisticsProducerComponent::GetOutputDataSize( unsigned long& constBase, 
								   double& inputMultiplier ) {
  // see header file for class documentation

  constBase = sizeof( AliHLTTPCEventStatistics );
  inputMultiplier = 0.0;
}

// ------------------------------------------------------------------------------------------
// Spawn function, return new instance of this class
AliHLTComponent* AliHLTTPCEventStatisticsProducerComponent::Spawn() {
  // see header file for class documentation

  return new AliHLTTPCEventStatisticsProducerComponent;
}


// ------------------------------------------------------------------------------------------
Int_t AliHLTTPCEventStatisticsProducerComponent::DoInit( int argc, const char** argv ) {
  // see header file for class documentation

  Int_t iResult = 0;
  
  // ** Defaults

  Int_t threshold = 0;
  
  // ** Argument handling

  TString argument = "";
  TString parameter = "";
  Int_t bMissingParam=0;
  
  for ( Int_t ii=0; ii<argc && iResult>=0; ii++ ) {
  
    argument = argv[ii];

    if ( argument.IsNull() ) continue;

    // -detector
    if ( ! argument.CompareTo("-clusterThreshold") ) {

      if ( ( bMissingParam=( ++ii >= argc ) ) ) break;

      parameter = argv[ii];  
      parameter.Remove( TString::kLeading, ' ' );
      
      if  (parameter.IsDigit() ) {
	threshold = (Int_t) parameter.Atoi();
	HLTInfo( "Threshold of clusters for long tracks is set to %d.", threshold );
      } 
      else {
	HLTError( "Cannot convert clusterThreshold  specifier '%s'.", parameter.Data() );
	iResult = -EINVAL;
	break;
      }
      
    } // if ( ! argument.CompareTo("-clusterThreshold") ) {
    
    // - unknow parameter
    else {
      iResult = -EINVAL;
      HLTError("Unknown argument '%s'", argument.Data() );
    }

  } // for ( Int_t ii=0; ii<argc && iResult>=0; ii++ ) {

  if ( bMissingParam ) {
    HLTError( "Missing parameter for argument '%s'.", argument.Data() );
    iResult = -EPROTO;
  }

  // set members
  
  fClusterThreshold =  threshold; 

  return iResult;
}

// ------------------------------------------------------------------------------------------
Int_t AliHLTTPCEventStatisticsProducerComponent::DoDeinit() {
  // see header file for class documentation

  if ( fEvStat )
    delete fEvStat;
  fEvStat = NULL;

  if ( fTracks ) 
    delete fTracks; 
  fTracks = NULL;

  return 0;
}

// ------------------------------------------------------------------------------------------
Int_t AliHLTTPCEventStatisticsProducerComponent::DoEvent( const AliHLTComponentEventData& /*evtData*/, AliHLTComponentTriggerData& /*trigData*/ ) {
  // see header file for class documentation

  const AliHLTComponentBlockData* iter = NULL;

  // ** No readout list for SOR and EOR event
  if ( GetFirstInputBlock( kAliHLTDataTypeSOR ) || GetFirstInputBlock( kAliHLTDataTypeEOR ) )
    return 0;
  
  //
  // ** Setup for new Event
  //
  InitializeEvent();
  
  //
  // ** Read in cluster from ClusterFinder
  //
  
  // ** Loop over all input blocks and specify which data format should be read
  for ( iter = GetFirstInputBlock(AliHLTTPCDefinitions::fgkClustersDataType); iter != NULL; iter = GetNextInputBlock() ) {
    
    AliHLTUInt8_t slice = AliHLTTPCDefinitions::GetMinSliceNr( *iter );
    AliHLTUInt8_t patch = AliHLTTPCDefinitions::GetMinPatchNr( *iter );

    HLTDebug ( "Input Data - TPC cluster - Slice/Patch: %d/%d.", slice, patch );

    AddClusters( iter->fPtr, (Int_t) slice, (Int_t) patch );
  } // for ( iter = GetFirstInputBlock(AliHLTTPCDefinitions::fgkClustersDataType); iter != NULL; iter = GetNextInputBlock() ) {
  

  //
  // ** Read in track segments from Tracker
  //

  iter = NULL;

  // ** Loop over all input blocks and specify which data format should be read
  for ( iter = GetFirstInputBlock(AliHLTTPCDefinitions::fgkTrackSegmentsDataType); iter != NULL; iter = GetNextInputBlock() ) {
    
    AliHLTUInt8_t slice = AliHLTTPCDefinitions::GetMinSliceNr( *iter );
    HLTDebug ( "Input Data - TPC track segments - Slice: %d.", slice );

    AddTracks( iter->fPtr, (Int_t) slice );
  } //   for ( iter = GetFirstInputBlock(AliHLTTPCDefinitions::fgkTrackSegmentsDataType); iter != NULL; iter = GetNextInputBlock() ) {
  
  //
  // ** Read in tracks from GlobalMerger
  //

  iter = NULL;

  // ** Loop over all input blocks and specify which data format should be read
  for ( iter = GetFirstInputBlock(AliHLTTPCDefinitions::fgkTracksDataType); iter != NULL; iter = GetNextInputBlock() ) {

    HLTDebug ( "Input Data - TPC track segments." );

    AddTracks( iter->fPtr );
  } //   for ( iter = GetFirstInputBlock(AliHLTTPCDefinitions::fgkTracksDataType); iter != NULL; iter = GetNextInputBlock() ) {
  

  TObject* iterObject = NULL;

  // ** GetESDs
  iterObject = (TObject* )GetFirstInputObject(kAliHLTDataTypeESDTree|kAliHLTDataOriginTPC);

  if ( iterObject ) {

    HLTDebug ( "Input Data - TPC ESD." );

    AddESD( (TTree*) iterObject );
  } 
  
  //
  // ** Produce event statistics
  //
  
  ProcessEvent();
  
  PushBack ( (TObject*) GetEventStatistics(), sizeof(AliHLTTPCEventStatistics), kAliHLTDataTypeEventStatistics|kAliHLTDataOriginTPC, (AliHLTUInt32_t) 0 );

  return 0;
}

// -- **********************************************************************************************
// -- *******************************   Processing Functions  **************************************
// -- **********************************************************************************************

// -- **********************************************************************************************
void AliHLTTPCEventStatisticsProducerComponent::InitializeEvent() {
  // see header file for class documentation
  
  if ( fEvStat )
    delete fEvStat;

  fEvStat = new AliHLTTPCEventStatistics();
  fEvStat->SetClusterThreshold( fClusterThreshold );

  // ** Initialize arrays to 0 
  memset( fNTracksPerSlice, -1, 36*sizeof(Int_t) ); 

  // ** New AliHLTTPCTrackArray
  if ( fTracks ) 
    delete fTracks; 
  fTracks = new AliHLTTPCTrackArray;
  
  fGlobalTracks = kFALSE;
  fNSlice = 0;
}

// -- **********************************************************************************************
void AliHLTTPCEventStatisticsProducerComponent::AddClusters( void* ptr, Int_t slice, Int_t patch ) {
  // see header file for class documentation

  const AliHLTTPCClusterData* clusterData = (const AliHLTTPCClusterData*) ptr;

  // these 2 variables have been introduced to avoid warning: unused variable in production compile
  Int_t sliceAntiWarning = slice;
  Int_t patchAntiWarning = patch;

  Int_t nSpacepoint = (Int_t) clusterData->fSpacePointCnt;
  HLTDebug( "%d Clusters found for slice %u - patch %u\n", nSpacepoint, sliceAntiWarning, patchAntiWarning );

  sliceAntiWarning = 0;
  patchAntiWarning = 0;

  // ** Add to event statistics
  fEvStat->AddNTotalCluster( nSpacepoint );

}

// -- **********************************************************************************************
void AliHLTTPCEventStatisticsProducerComponent::AddTracks( void* ptr, Int_t slice ) {
  // see header file for class documentation

  const AliHLTTPCTrackletData* trackData = (const AliHLTTPCTrackletData*) ptr;

  Int_t nTracks = (Int_t) trackData->fTrackletCnt;

  AliHLTTPCTrackSegmentData* segmentData = (AliHLTTPCTrackSegmentData*) &( trackData->fTracklets[0] );

  // ** Tracks which are not from GlobalMerger have to be transformed to global Coordinates ( bTransform=1, else 0 )
  Int_t bTransform;

  
  // ** Global tracks
  if ( slice == -1 ) {
    HLTDebug( "%d tracks found for event.", nTracks );
  
    bTransform = 0;
    fGlobalTracks = kTRUE;
  } 
  else { 
    HLTDebug( "%d tracks found for slice %u.", nTracks, slice );

    // ** Fill number if tracks per slice
    fNTracksPerSlice[slice] = (Int_t) trackData->fTrackletCnt;
    fNSlice++;

    bTransform = 1;
  }
  
  fTracks->FillTracksChecked( segmentData, nTracks, 0, slice, bTransform );

}

// -- **********************************************************************************************
void AliHLTTPCEventStatisticsProducerComponent::AddESD( TTree* esdTree ) {
  // see header file for class documentation

  AliESDEvent* esd = new AliESDEvent();
  esd->ReadFromTree(esdTree);
  esdTree->GetEntry(0);

  HLTWarning("Number of tracks found : %d", esd->GetNumberOfTracks() );
  
  if ( esd )
    delete esd;

}

// -- **********************************************************************************************
void AliHLTTPCEventStatisticsProducerComponent::ProcessEvent() { 
  // see header file for class documentation

  // ** Total number of tracks -- Add to event statistics
  fEvStat->SetNTotalTracks( fTracks->GetNTracks() ) ;

  // ** Loop over all tracks
  for( Int_t trackNdx=0; trackNdx < fTracks->GetNTracks(); trackNdx++ ) {

    AliHLTTPCTrack *track = fTracks->GetCheckedTrack( trackNdx ); 
    if( !track ) continue;

    // ** Used cluster -- Add to event statistics
    fEvStat->AddNUsedCluster( track->GetNHits() );

    // ** If is long track -- Add to event statistics
    if ( track->GetNHits() >= fClusterThreshold )
      fEvStat->AddNTracksAboveClusterThreshold();
  }

  // ** Average of ( number of clusters per track ), floored -- Add to event statistics
  //    N used cluster / N tracks
  if (  fEvStat->GetNTotalTracks() > 0 ) {
    fEvStat->SetAvgClusterPerTrack( (Int_t) TMath::FloorNint( (Double_t) fEvStat->GetNUsedCluster() / (Double_t) fEvStat->GetNTotalTracks()  ) );
  }
  fEvStat->SetAvgClusterPerTrack( 0 );

  if ( fGlobalTracks ) FillTracksPerSlice();

  // ** Average  of ( tracks per slice )
  if ( fNSlice > 0 )
    fEvStat->SetNAvgTracksPerSector( (Int_t) TMath::FloorNint( (Double_t) fEvStat->GetNTotalTracks() / (Double_t) fNSlice ) );
  else
    fEvStat->SetNAvgTracksPerSector( 0 );

  // ** Max and Min of Tracks per slice 
  for ( Int_t ii=0; ii < 36; ii++ ) {

    if ( fNTracksPerSlice[ii] == -1 ) continue;

    if ( fNTracksPerSlice[ii] > fEvStat->GetNMaxTracksPerSector() ) 
      fEvStat->SetNMaxTracksPerSector( fNTracksPerSlice[ii] );

    if ( fNTracksPerSlice[ii] < fEvStat->GetNMinTracksPerSector() ) 
      fEvStat->SetNMinTracksPerSector( fNTracksPerSlice[ii] );
  }

  // ** Info prints

  HLTInfo( "Total N Tracks : %d", fEvStat->GetNTotalTracks() );
  HLTInfo( "Total N Tracks with more than %d cluster : %d",  fEvStat->GetClusterThreshold(), fEvStat->GetNTracksAboveClusterThreshold() );
  HLTInfo( "Min N Tracks per slice : %d", fEvStat->GetNMinTracksPerSector() );
  HLTInfo( "Max N Tracks per slice : %d", fEvStat->GetNMaxTracksPerSector() );
  HLTInfo( "Avg N Tracks per slice : %d", fEvStat->GetNAvgTracksPerSector() );

  HLTInfo( "Total N Cluster : %d", fEvStat->GetNTotalCluster() );
  HLTInfo( "Used N Cluster : %d", fEvStat->GetNUsedCluster() );
  HLTInfo( "Average (Cluster per track) : %d", fEvStat->GetAvgClusterPerTrack() );
}

// -- **********************************************************************************************
void AliHLTTPCEventStatisticsProducerComponent::FillTracksPerSlice() { 
  // see header file for class documentation

  // fill fNTracksPerSlice[36];   
  // fill fNSlice
}
Commit	Line	Data
2ff24e4c	1	//-- Mode: C++ --
	2	// $Id$
	3	/**************************************************************************
	4	* This file is property of and copyright by the ALICE HLT Project *
	5	* ALICE Experiment at CERN, All rights reserved. *
	6	* *
	7	* Primary Authors: Jochen Thaeder <thaeder@kip.uni-heidelberg.de> *
	8	* for The ALICE HLT Project. *
	9	* *
	10	* Permission to use, copy, modify and distribute this software and its *
	11	* documentation strictly for non-commercial purposes is hereby granted *
	12	* without fee, provided that the above copyright notice appears in all *
	13	* copies and that both the copyright notice and this permission notice *
	14	* appear in the supporting documentation. The authors make no claims *
	15	* about the suitability of this software for any purpose. It is *
	16	* provided "as is" without express or implied warranty. *
	17	**************************************************************************/
	18
	19	/** @file AliHLTTPCEventStatisticsProducerComponent.cxx
	20	@author Jochen Thaeder
	21	@date
	22	@brief Component for the @see AliHLTTPCEventStatisticsProducer class
	23	*/
	24
	25	// see header file for class documentation
	26	// or
	27	// refer to README to build package
	28	// or
	29	// visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
	30
	31	#if __GNUC__ >= 3
	32	using namespace std;
	33	#endif
	34
	35	#include "AliHLTTPCEventStatisticsProducerComponent.h"
	36
	37	#include "AliHLTTPCDefinitions.h"
	38	#include "AliHLTTPCClusterDataFormat.h"
	39	#include "AliHLTTPCTrackSegmentData.h"
	40	#include "AliHLTTPCTrackletDataFormat.h"
	41	#include "AliHLTTPCTrack.h"
	42
	43	#include "TMath.h"
	44
	45	#include <cerrno>
	46
672f8b8c	47	/** ROOT macro for the implementation of ROOT specific class methods */
2ff24e4c	48	ClassImp(AliHLTTPCEventStatisticsProducerComponent)
	49
	50	// ------------------------------------------------------------------------------------------
	51	AliHLTTPCEventStatisticsProducerComponent::AliHLTTPCEventStatisticsProducerComponent() :
	52	fClusterThreshold(0),
	53	fEvStat(NULL),
	54	fNTracksPerSlice(),
	55	fTracks(NULL),
	56	fGlobalTracks(kFALSE),
	57	fNSlice(0) {
	58	// see header file for class documentation
	59	// or
	60	// refer to README to build package
	61	// or
	62	// visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
	63	}
	64
	65	// ------------------------------------------------------------------------------------------
	66	AliHLTTPCEventStatisticsProducerComponent::~AliHLTTPCEventStatisticsProducerComponent() {
	67	// see header file for class documentation
	68	}
	69
	70	// ------------------------------------------------------------------------------------------
	71	const char* AliHLTTPCEventStatisticsProducerComponent::GetComponentID() {
	72	// see header file for class documentation
	73	return "TPCEventStatisticsProducer";
	74	}
	75
	76	// ------------------------------------------------------------------------------------------
	77	void AliHLTTPCEventStatisticsProducerComponent::GetInputDataTypes(AliHLTComponentDataTypeList& list) {
	78	// see header file for class documentation
	79
	80	list.clear();
	81	list.push_back( AliHLTTPCDefinitions::fgkClustersDataType );
	82	list.push_back( AliHLTTPCDefinitions::fgkTracksDataType );
	83	list.push_back( AliHLTTPCDefinitions::fgkTrackSegmentsDataType );
	84	}
	85
	86	// ------------------------------------------------------------------------------------------
	87	AliHLTComponentDataType AliHLTTPCEventStatisticsProducerComponent::GetOutputDataType() {
	88	// see header file for class documentation
	89
	90	return kAliHLTDataTypeEventStatistics\|kAliHLTDataOriginTPC;
	91	}
	92
	93	// ------------------------------------------------------------------------------------------
	94	void AliHLTTPCEventStatisticsProducerComponent::GetOutputDataSize( unsigned long& constBase,
	95	double& inputMultiplier ) {
	96	// see header file for class documentation
	97
	98	constBase = sizeof( AliHLTTPCEventStatistics );
	99	inputMultiplier = 0.0;
	100	}
	101
	102	// ------------------------------------------------------------------------------------------
	103	// Spawn function, return new instance of this class
	104	AliHLTComponent* AliHLTTPCEventStatisticsProducerComponent::Spawn() {
	105	// see header file for class documentation
	106
	107	return new AliHLTTPCEventStatisticsProducerComponent;
	108	}
	109
	110
	111	// ------------------------------------------------------------------------------------------
112	Int_t AliHLTTPCEventStatisticsProducerComponent::DoInit( int argc, const char** argv ) {
113	// see header file for class documentation
114
115	Int_t iResult = 0;
116
117	// ** Defaults
118
119	Int_t threshold = 0;
120
121	// ** Argument handling
122
123	TString argument = "";
124	TString parameter = "";
125	Int_t bMissingParam=0;
126
127	for ( Int_t ii=0; ii<argc && iResult>=0; ii++ ) {
128
129	argument = argv[ii];
130
131	if ( argument.IsNull() ) continue;
132
133	// -detector
134	if ( ! argument.CompareTo("-clusterThreshold") ) {
135
136	if ( ( bMissingParam=( ++ii >= argc ) ) ) break;
137
138	parameter = argv[ii];
139	parameter.Remove( TString::kLeading, ' ' );
140
141	if (parameter.IsDigit() ) {
142	threshold = (Int_t) parameter.Atoi();
143	HLTInfo( "Threshold of clusters for long tracks is set to %d.", threshold );
144	}
145	else {
146	HLTError( "Cannot convert clusterThreshold specifier '%s'.", parameter.Data() );
147	iResult = -EINVAL;
148	break;
149	}
150
151	} // if ( ! argument.CompareTo("-clusterThreshold") ) {
152
153	// - unknow parameter
154	else {
155	iResult = -EINVAL;
156	HLTError("Unknown argument '%s'", argument.Data() );
157	}
158
159	} // for ( Int_t ii=0; ii<argc && iResult>=0; ii++ ) {
160
161	if ( bMissingParam ) {
162	HLTError( "Missing parameter for argument '%s'.", argument.Data() );
163	iResult = -EPROTO;
164	}
165
166	// set members
167
168	fClusterThreshold = threshold;
169
170	return iResult;
171	}
172
173	// ------------------------------------------------------------------------------------------
174	Int_t AliHLTTPCEventStatisticsProducerComponent::DoDeinit() {
175	// see header file for class documentation
176
177	if ( fEvStat )
178	delete fEvStat;
179	fEvStat = NULL;
180
181	if ( fTracks )
182	delete fTracks;
183	fTracks = NULL;
184
185	return 0;
186	}
187
188	// ------------------------------------------------------------------------------------------
2b4385d9	189	Int_t AliHLTTPCEventStatisticsProducerComponent::DoEvent( const AliHLTComponentEventData& /evtData/, AliHLTComponentTriggerData& /trigData/ ) {
2ff24e4c	190	// see header file for class documentation
	191
	192	const AliHLTComponentBlockData* iter = NULL;
	193
	194	// ** No readout list for SOR and EOR event
	195	if ( GetFirstInputBlock( kAliHLTDataTypeSOR ) \|\| GetFirstInputBlock( kAliHLTDataTypeEOR ) )
	196	return 0;
	197
	198	//
	199	// ** Setup for new Event
	200	//
	201	InitializeEvent();
	202
	203	//
	204	// ** Read in cluster from ClusterFinder
	205	//
	206
	207	// ** Loop over all input blocks and specify which data format should be read
	208	for ( iter = GetFirstInputBlock(AliHLTTPCDefinitions::fgkClustersDataType); iter != NULL; iter = GetNextInputBlock() ) {
	209
	210	AliHLTUInt8_t slice = AliHLTTPCDefinitions::GetMinSliceNr( *iter );
	211	AliHLTUInt8_t patch = AliHLTTPCDefinitions::GetMinPatchNr( *iter );
	212
	213	HLTDebug ( "Input Data - TPC cluster - Slice/Patch: %d/%d.", slice, patch );
	214
5eefc803	215	AddClusters( iter->fPtr, (Int_t) slice, (Int_t) patch );
2ff24e4c	216	} // for ( iter = GetFirstInputBlock(AliHLTTPCDefinitions::fgkClustersDataType); iter != NULL; iter = GetNextInputBlock() ) {
	217
	218
	219	//
	220	// ** Read in track segments from Tracker
	221	//
	222
	223	iter = NULL;
	224
	225	// ** Loop over all input blocks and specify which data format should be read
	226	for ( iter = GetFirstInputBlock(AliHLTTPCDefinitions::fgkTrackSegmentsDataType); iter != NULL; iter = GetNextInputBlock() ) {
	227
	228	AliHLTUInt8_t slice = AliHLTTPCDefinitions::GetMinSliceNr( *iter );
	229	HLTDebug ( "Input Data - TPC track segments - Slice: %d.", slice );
	230
5eefc803	231	AddTracks( iter->fPtr, (Int_t) slice );
2ff24e4c	232	} // for ( iter = GetFirstInputBlock(AliHLTTPCDefinitions::fgkTrackSegmentsDataType); iter != NULL; iter = GetNextInputBlock() ) {
	233
	234	//
	235	// ** Read in tracks from GlobalMerger
	236	//
	237
	238	iter = NULL;
	239
	240	// ** Loop over all input blocks and specify which data format should be read
	241	for ( iter = GetFirstInputBlock(AliHLTTPCDefinitions::fgkTracksDataType); iter != NULL; iter = GetNextInputBlock() ) {
1d229444	242
2ff24e4c	243	HLTDebug ( "Input Data - TPC track segments." );
2ff24e4c	244
5eefc803	245	AddTracks( iter->fPtr );
2ff24e4c	246	} // for ( iter = GetFirstInputBlock(AliHLTTPCDefinitions::fgkTracksDataType); iter != NULL; iter = GetNextInputBlock() ) {
	247
	248
1d229444	249	TObject* iterObject = NULL;
	250
	251	// ** GetESDs
	252	iterObject = (TObject* )GetFirstInputObject(kAliHLTDataTypeESDTree\|kAliHLTDataOriginTPC);
	253
	254	if ( iterObject ) {
	255
	256	HLTDebug ( "Input Data - TPC ESD." );
	257
	258	AddESD( (TTree*) iterObject );
	259	}
	260
2ff24e4c	261	//
	262	// ** Produce event statistics
	263	//
	264
	265	ProcessEvent();
	266
	267	PushBack ( (TObject*) GetEventStatistics(), sizeof(AliHLTTPCEventStatistics), kAliHLTDataTypeEventStatistics\|kAliHLTDataOriginTPC, (AliHLTUInt32_t) 0 );
	268
	269	return 0;
	270	}
	271
	272	// -- **********************************************************************************************
	273	// -- ***************************** Processing Functions ************************************
	274	// -- **********************************************************************************************
	275
	276	// -- **********************************************************************************************
	277	void AliHLTTPCEventStatisticsProducerComponent::InitializeEvent() {
	278	// see header file for class documentation
	279
	280	if ( fEvStat )
	281	delete fEvStat;
	282
	283	fEvStat = new AliHLTTPCEventStatistics();
	284	fEvStat->SetClusterThreshold( fClusterThreshold );
	285
	286	// ** Initialize arrays to 0
	287	memset( fNTracksPerSlice, -1, 36*sizeof(Int_t) );
	288
	289	// ** New AliHLTTPCTrackArray
	290	if ( fTracks )
	291	delete fTracks;
	292	fTracks = new AliHLTTPCTrackArray;
	293
	294	fGlobalTracks = kFALSE;
	295	fNSlice = 0;
	296	}
	297
	298	// -- **********************************************************************************************
5eefc803	299	void AliHLTTPCEventStatisticsProducerComponent::AddClusters( void* ptr, Int_t slice, Int_t patch ) {
2ff24e4c	300	// see header file for class documentation
	301
	302	const AliHLTTPCClusterData* clusterData = (const AliHLTTPCClusterData*) ptr;
	303
5eefc803	304	// these 2 variables have been introduced to avoid warning: unused variable in production compile
	305	Int_t sliceAntiWarning = slice;
	306	Int_t patchAntiWarning = patch;
	307
2ff24e4c	308	Int_t nSpacepoint = (Int_t) clusterData->fSpacePointCnt;
5eefc803	309	HLTDebug( "%d Clusters found for slice %u - patch %u\n", nSpacepoint, sliceAntiWarning, patchAntiWarning );
	310
	311	sliceAntiWarning = 0;
	312	patchAntiWarning = 0;
2ff24e4c	313
	314	// ** Add to event statistics
	315	fEvStat->AddNTotalCluster( nSpacepoint );
	316
	317	}
	318
	319	// -- **********************************************************************************************
5eefc803	320	void AliHLTTPCEventStatisticsProducerComponent::AddTracks( void* ptr, Int_t slice ) {
2ff24e4c	321	// see header file for class documentation
	322
	323	const AliHLTTPCTrackletData* trackData = (const AliHLTTPCTrackletData*) ptr;
	324
	325	Int_t nTracks = (Int_t) trackData->fTrackletCnt;
	326
	327	AliHLTTPCTrackSegmentData* segmentData = (AliHLTTPCTrackSegmentData*) &( trackData->fTracklets[0] );
	328
	329	// ** Tracks which are not from GlobalMerger have to be transformed to global Coordinates ( bTransform=1, else 0 )
	330	Int_t bTransform;
	331
	332
	333	// ** Global tracks
	334	if ( slice == -1 ) {
	335	HLTDebug( "%d tracks found for event.", nTracks );
	336
	337	bTransform = 0;
	338	fGlobalTracks = kTRUE;
	339	}
	340	else {
	341	HLTDebug( "%d tracks found for slice %u.", nTracks, slice );
	342
	343	// ** Fill number if tracks per slice
	344	fNTracksPerSlice[slice] = (Int_t) trackData->fTrackletCnt;
	345	fNSlice++;
	346
	347	bTransform = 1;
	348	}
	349
febeb705	350	fTracks->FillTracksChecked( segmentData, nTracks, 0, slice, bTransform );
2ff24e4c	351
	352	}
	353
1d229444	354	// -- **********************************************************************************************
	355	void AliHLTTPCEventStatisticsProducerComponent::AddESD( TTree* esdTree ) {
	356	// see header file for class documentation
	357
	358	AliESDEvent* esd = new AliESDEvent();
	359	esd->ReadFromTree(esdTree);
	360	esdTree->GetEntry(0);
	361
	362	HLTWarning("Number of tracks found : %d", esd->GetNumberOfTracks() );
	363
	364	if ( esd )
	365	delete esd;
	366
	367	}
	368
2ff24e4c	369	// -- **********************************************************************************************
	370	void AliHLTTPCEventStatisticsProducerComponent::ProcessEvent() {
	371	// see header file for class documentation
	372
	373	// ** Total number of tracks -- Add to event statistics
	374	fEvStat->SetNTotalTracks( fTracks->GetNTracks() ) ;
	375
	376	// ** Loop over all tracks
	377	for( Int_t trackNdx=0; trackNdx < fTracks->GetNTracks(); trackNdx++ ) {
	378
	379	AliHLTTPCTrack *track = fTracks->GetCheckedTrack( trackNdx );
	380	if( !track ) continue;
	381
	382	// ** Used cluster -- Add to event statistics
	383	fEvStat->AddNUsedCluster( track->GetNHits() );
	384
	385	// ** If is long track -- Add to event statistics
	386	if ( track->GetNHits() >= fClusterThreshold )
	387	fEvStat->AddNTracksAboveClusterThreshold();
	388	}
	389
	390	// ** Average of ( number of clusters per track ), floored -- Add to event statistics
	391	// N used cluster / N tracks
	392	if ( fEvStat->GetNTotalTracks() > 0 ) {
	393	fEvStat->SetAvgClusterPerTrack( (Int_t) TMath::FloorNint( (Double_t) fEvStat->GetNUsedCluster() / (Double_t) fEvStat->GetNTotalTracks() ) );
	394	}
	395	fEvStat->SetAvgClusterPerTrack( 0 );
	396
	397	if ( fGlobalTracks ) FillTracksPerSlice();
	398
	399	// ** Average of ( tracks per slice )
	400	if ( fNSlice > 0 )
	401	fEvStat->SetNAvgTracksPerSector( (Int_t) TMath::FloorNint( (Double_t) fEvStat->GetNTotalTracks() / (Double_t) fNSlice ) );
	402	else
	403	fEvStat->SetNAvgTracksPerSector( 0 );
	404
	405	// ** Max and Min of Tracks per slice
	406	for ( Int_t ii=0; ii < 36; ii++ ) {
	407
	408	if ( fNTracksPerSlice[ii] == -1 ) continue;
	409
	410	if ( fNTracksPerSlice[ii] > fEvStat->GetNMaxTracksPerSector() )
	411	fEvStat->SetNMaxTracksPerSector( fNTracksPerSlice[ii] );
	412
	413	if ( fNTracksPerSlice[ii] < fEvStat->GetNMinTracksPerSector() )
	414	fEvStat->SetNMinTracksPerSector( fNTracksPerSlice[ii] );
	415	}
	416
	417	// ** Info prints
	418
	419	HLTInfo( "Total N Tracks : %d", fEvStat->GetNTotalTracks() );
	420	HLTInfo( "Total N Tracks with more than %d cluster : %d", fEvStat->GetClusterThreshold(), fEvStat->GetNTracksAboveClusterThreshold() );
	421	HLTInfo( "Min N Tracks per slice : %d", fEvStat->GetNMinTracksPerSector() );
	422	HLTInfo( "Max N Tracks per slice : %d", fEvStat->GetNMaxTracksPerSector() );
	423	HLTInfo( "Avg N Tracks per slice : %d", fEvStat->GetNAvgTracksPerSector() );
	424
	425	HLTInfo( "Total N Cluster : %d", fEvStat->GetNTotalCluster() );
	426	HLTInfo( "Used N Cluster : %d", fEvStat->GetNUsedCluster() );
	427	HLTInfo( "Average (Cluster per track) : %d", fEvStat->GetAvgClusterPerTrack() );
	428	}
	429
	430	// -- **********************************************************************************************
	431	void AliHLTTPCEventStatisticsProducerComponent::FillTracksPerSlice() {
	432	// see header file for class documentation
433
434	// fill fNTracksPerSlice[36];
435	// fill fNSlice
436	}