// $Id$
-/**************************************************************************
- * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
- * *
- * Authors: Matthias Richter <Matthias.Richter@ift.uib.no> *
- * Timm Steinbeck <timm@kip.uni-heidelberg.de> *
- * Jochen Thaeder <thaeder@kip.uni-heidelberg.de> *
- * for The ALICE Off-line 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. *
- **************************************************************************/
-
-///////////////////////////////////////////////////////////////////////////////
-// //
-// a TPC cluster finder processing component for the HLT //
-// useable for packed data or unpacked data //
-// //
-///////////////////////////////////////////////////////////////////////////////
-
+//**************************************************************************
+//* This file is property of and copyright by the ALICE HLT Project *
+//* ALICE Experiment at CERN, All rights reserved. *
+//* *
+//* Primary Authors: Timm Steinbeck, Matthias Richter *
+//* Developers: Kenneth Aamodt <kenneth.aamodt@student.uib.no> *
+//* for The ALICE HLT Project. *
+//* *
+//* Permission to use, copy, modify and distribute this software and its *
+//* documentation strictly for non-commercial purposes is hereby granted *
+//* without fee, provided that the above copyright notice appears in all *
+//* copies and that both the copyright notice and this permission notice *
+//* appear in the supporting documentation. The authors make no claims *
+//* about the suitability of this software for any purpose. It is *
+//* provided "as is" without express or implied warranty. *
+//**************************************************************************
+
+/** @file AliHLTTPCClusterFinderComponent.cxx
+ @author Kenneth Aamodt <kenneth.aamodt@student.uib.no>
+ @date
+ @brief The TPC cluster finder processing component
+*/
#if __GNUC__>= 3
using namespace std;
#endif
-#include "AliHLTTPCLogging.h"
#include "AliHLTTPCClusterFinderComponent.h"
#include "AliHLTTPCDigitReaderPacked.h"
#include "AliHLTTPCDigitReaderUnpacked.h"
-#include "AliHLTTPCDigitReaderRaw.h"
+#include "AliHLTTPCDigitReaderDecoder.h"
+#include "AliHLTTPCDigitReader32Bit.h"
#include "AliHLTTPCClusterFinder.h"
#include "AliHLTTPCSpacePointData.h"
-#include "AliHLTTPCRawDataFormat.h"
#include "AliHLTTPCClusterDataFormat.h"
#include "AliHLTTPCTransform.h"
-#include <stdlib.h>
-#include <errno.h>
-
-// this is a global object used for automatic component registration, do not use this
-AliHLTTPCClusterFinderComponent gAliHLTTPCClusterFinderComponentPacked(true);
-AliHLTTPCClusterFinderComponent gAliHLTTPCClusterFinderComponentUnpacked(false);
-
+#include "AliHLTTPCClusters.h"
+#include "AliHLTTPCDefinitions.h"
+#include "AliGRPObject.h"
+#include "AliCDBEntry.h"
+#include "AliCDBManager.h"
+#include "AliTPCcalibDB.h"
+#include "AliTPCCalPad.h"
+#include "AliTPCParam.h"
+#include "AliTPCTransform.h"
+
+//#include "AliHLTTPCCAInputDataCompressorComponent.h"
+//#include "AliHLTTPCCADef.h"
+
+#include <cstdlib>
+#include <cerrno>
+#include "TString.h"
+#include "TObjString.h"
+#include "TObjArray.h"
+#include "AliCDBEntry.h"
+#include "AliCDBManager.h"
+#include "AliCDBStorage.h"
+#include "TGeoGlobalMagField.h"
+#include "AliGeomManager.h"
+
+#include <sys/time.h>
+
+/** ROOT macro for the implementation of ROOT specific class methods */
ClassImp(AliHLTTPCClusterFinderComponent)
-AliHLTTPCClusterFinderComponent::AliHLTTPCClusterFinderComponent(bool packed)
+AliHLTTPCClusterFinderComponent::AliHLTTPCClusterFinderComponent(int mode)
:
- // use fPackedSwitch = true for packed inputtype "gkDDLPackedRawDataType"
- // use fPackedSwitch = false for unpacked inputtype "gkUnpackedRawDataType"
- fPackedSwitch(packed),
-
fClusterFinder(NULL),
fReader(NULL),
- fClusterDeconv(true),
+ fDeconvTime(kFALSE),
+ fTS(0),
+ fDeconvPad(kFALSE),
+ fClusterDeconv(false),
fXYClusterError(-1),
- fZClusterError(-1)
+ fZClusterError(-1),
+ fModeSwitch(mode),
+ fUnsorted(1),
+ fPatch(0),
+ fGetActivePads(0),
+ fFirstTimeBin(-1),
+ fLastTimeBin(-1),
+ fDoMC(kFALSE),
+ fReleaseMemory( kFALSE ),
+ fBenchmark("TPCClusterFinder")
{
+ // 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 (fModeSwitch!=kClusterFinderPacked &&
+ fModeSwitch!=kClusterFinderUnpacked &&
+ fModeSwitch!=kClusterFinderDecoder &&
+ fModeSwitch!=kClusterFinder32Bit) {
+ HLTFatal("unknown digit reader type");
+ }
}
-AliHLTTPCClusterFinderComponent::AliHLTTPCClusterFinderComponent(const AliHLTTPCClusterFinderComponent&)
- :
- fPackedSwitch(0),
- fClusterFinder(NULL),
- fReader(NULL),
- fClusterDeconv(true),
- fXYClusterError(-1),
- fZClusterError(-1)
+AliHLTTPCClusterFinderComponent::~AliHLTTPCClusterFinderComponent()
{
- HLTFatal("copy constructor untested");
+ // see header file for class documentation
}
-AliHLTTPCClusterFinderComponent& AliHLTTPCClusterFinderComponent::operator=(const AliHLTTPCClusterFinderComponent&)
-{
- HLTFatal("assignment operator untested");
- return *this;
-}
-
-AliHLTTPCClusterFinderComponent::~AliHLTTPCClusterFinderComponent()
- {
- }
-
// Public functions to implement AliHLTComponent's interface.
// These functions are required for the registration process
const char* AliHLTTPCClusterFinderComponent::GetComponentID()
- {
- if (fPackedSwitch) return "TPCClusterFinderPacked";
- else return "TPCClusterFinderUnpacked";
- }
+{
+ // see header file for class documentation
+ switch(fModeSwitch){
+ case kClusterFinderPacked:
+ return "TPCClusterFinderPacked";
+ break;
+ case kClusterFinderUnpacked:
+ return "TPCClusterFinderUnpacked";
+ break;
+ case kClusterFinderDecoder:
+ return "TPCClusterFinderDecoder";
+ break;
+ case kClusterFinder32Bit:
+ return "TPCClusterFinder32Bit";
+ break;
+ }
+ return "";
+}
-void AliHLTTPCClusterFinderComponent::GetInputDataTypes( vector<AliHLTComponent_DataType>& list)
- {
- list.clear();
- if (fPackedSwitch) list.push_back( AliHLTTPCDefinitions::gkDDLPackedRawDataType );
- else list.push_back( AliHLTTPCDefinitions::gkUnpackedRawDataType );
-
- }
+void AliHLTTPCClusterFinderComponent::GetInputDataTypes( vector<AliHLTComponentDataType>& list)
+{
+ // see header file for class documentation
+ list.clear();
+ switch(fModeSwitch){
+ case kClusterFinderPacked:
+ list.push_back( kAliHLTDataTypeDDLRaw | kAliHLTDataOriginTPC );
+ break;
+ case kClusterFinderUnpacked:
+ list.push_back( AliHLTTPCDefinitions::fgkUnpackedRawDataType );
+ break;
+ case kClusterFinderDecoder:
+ list.push_back( kAliHLTDataTypeDDLRaw | kAliHLTDataOriginTPC );
+ break;
+ case kClusterFinder32Bit:
+ list.push_back( kAliHLTDataTypeDDLRaw | kAliHLTDataOriginTPC );
+ break;
+ }
+}
-AliHLTComponent_DataType AliHLTTPCClusterFinderComponent::GetOutputDataType()
- {
- return AliHLTTPCDefinitions::gkClustersDataType;
- }
+AliHLTComponentDataType AliHLTTPCClusterFinderComponent::GetOutputDataType()
+{
+ // see header file for class documentation
+ return kAliHLTMultipleDataType;
+}
+
+int AliHLTTPCClusterFinderComponent::GetOutputDataTypes(AliHLTComponentDataTypeList& tgtList)
+
+{
+ // see header file for class documentation
+ tgtList.clear();
+ tgtList.push_back(AliHLTTPCDefinitions::fgkClustersDataType);
+ tgtList.push_back(kAliHLTDataTypeHwAddr16);
+ //tgtList.push_back(AliHLTTPCCADefinitions::fgkCompressedInputDataType);
+ return tgtList.size();
+}
void AliHLTTPCClusterFinderComponent::GetOutputDataSize( unsigned long& constBase, double& inputMultiplier )
- {
- // XXX TODO: Find more realistic values.
- constBase = 0;
- if (fPackedSwitch) inputMultiplier = (6 * 0.4);
- else inputMultiplier = 0.4;
- }
+{
+ // see header file for class documentation
+ // XXX TODO: Find more realistic values.
+ constBase = 0;
+ switch(fModeSwitch){
+ case kClusterFinderPacked:
+ inputMultiplier = (6 * 0.4);
+ break;
+ case kClusterFinderUnpacked:
+ inputMultiplier = 0.4;
+ break;
+ case kClusterFinderDecoder:
+ inputMultiplier = (6 * 0.4);
+ break;
+ case kClusterFinder32Bit:
+ inputMultiplier = (6 * 0.4);
+ break;
+ }
+}
AliHLTComponent* AliHLTTPCClusterFinderComponent::Spawn()
- {
- return new AliHLTTPCClusterFinderComponent(fPackedSwitch);
- }
+{
+ // see header file for class documentation
+ return new AliHLTTPCClusterFinderComponent(fModeSwitch);
+}
int AliHLTTPCClusterFinderComponent::DoInit( int argc, const char** argv )
- {
- if ( fClusterFinder )
- return EINPROGRESS;
+{
+ // see header file for class documentation
+ if ( fClusterFinder )
+ return -EINPROGRESS;
+
+ //Test if the OCDB entries used by AliTPCTransform is availible
+ AliTPCcalibDB* calib=AliTPCcalibDB::Instance();
+ //
+ if(!calib){
+ HLTError("AliTPCcalibDB does not exist");
+ return -ENOENT;
+ }
+
+ fTS = calib->GetTransform();
+
+ calib->SetRun(GetRunNo());
+ calib->UpdateRunInformations(GetRunNo());
+ AliTPCCalPad * time0TPC = calib->GetPadTime0();
+ if(!time0TPC){
+ HLTError("OCDB entry TPC/Calib/PadTime0 (AliTPCcalibDB::GetPadTime0()) is not available.");
+ return -ENOENT;
+ }
+
+ AliTPCParam * param = calib->GetParameters();
+ if(!param){
+ HLTError("OCDB entry TPC/Calib/Parameters (AliTPCcalibDB::GetParameters()) is not available.");
+ return -ENOENT;
+ }
+
+ // Check field
+ if (!TGeoGlobalMagField::Instance()) {
+ HLTError("magnetic field not initialized, please set up TGeoGlobalMagField and AliMagF");
+ return -ENODEV;
+ }
+ calib->SetExBField(GetBz());
+
+ if(!AliGeomManager::GetGeometry()){
+ AliGeomManager::LoadGeometry();
+ }
+
+ fClusterFinder = new AliHLTTPCClusterFinder();
+
+ TObject* pOCDBEntry=LoadAndExtractOCDBObject("GRP/GRP/Data");
+ AliGRPObject* pGRP=pOCDBEntry?dynamic_cast<AliGRPObject*>(pOCDBEntry):NULL;
+ TString beamType;
+ if (pGRP) {
+ beamType=pGRP->GetBeamType();
+ }
+
+ // first configure the default
+ int iResult = 0;
+ TString cdbPath="HLT/ConfigTPC/";
+ cdbPath+=GetComponentID();
+ iResult=ConfigureFromCDBTObjString(cdbPath, beamType.Data());
+
+ // configure from the command line parameters if specified
+ if (iResult>=0 && argc>0)
+ iResult=ConfigureFromArgumentString(argc, argv);
+ // return iResult;
+
+ /*
+ Int_t iResult=0;
+ TString configuration="";
+ TString argument="";
+ for (int i=0; i<argc && iResult>=0; i++) {
+ argument=argv[i];
+ if (!configuration.IsNull()) configuration+=" ";
+ configuration+=argument;
+ }
+
+ if (!configuration.IsNull()) {
+ iResult=Configure(configuration.Data());
+ } else {
+ iResult=Reconfigure(NULL, NULL);
+ }
+ */
+
+ //Checking for conflicting arguments
+ if(fClusterDeconv){
+ if(fDeconvPad==kTRUE || fDeconvTime==kTRUE){
+ HLTWarning("Conflicting arguments: argument 'pp-run' will be ignored.");
+ }
+ }
+ if(fClusterFinder->GetOccupancyLimit()!=1.0 && fUnsorted){
+ HLTWarning("Argument 'occupancy-limit' is deprecated when doing unsorted data reading.");
+ }
+ if(fGetActivePads==kTRUE && fUnsorted==kFALSE){
+ HLTWarning("Argument '-active-pads' only work with unsorted data reading. Active pads list will not be produced.");
+ }
+
+
+ // Choose reader
+ if (fModeSwitch==kClusterFinderPacked) {
+ HLTDebug("using AliHLTTPCDigitReaderPacked");
+ fReader = new AliHLTTPCDigitReaderPacked();
+ if(fUnsorted==1){ fReader->SetUnsorted(kTRUE); }
+ fClusterFinder->SetReader(fReader);
+ }
+ else if(fModeSwitch==kClusterFinderUnpacked){
+ HLTDebug("using AliHLTTPCDigitReaderUnpacked");
+ fReader = new AliHLTTPCDigitReaderUnpacked();
+ if(fUnsorted==1){ fReader->SetUnsorted(kTRUE); }
+ fClusterFinder->SetReader(fReader);
+ }
+ else if(fModeSwitch==kClusterFinderDecoder){
+ HLTDebug("using AliHLTTPCDigitReaderDecoder");
+ fReader = new AliHLTTPCDigitReaderDecoder();
+ fClusterFinder->SetReader(fReader);
+ }
+ else if(fModeSwitch==kClusterFinder32Bit){
+ HLTDebug("using AliHLTTPCDigitReader32Bit");
+ fReader = new AliHLTTPCDigitReader32Bit();
+ fClusterFinder->SetReader(fReader);
+ fClusterFinder->Set32BitFormat(kTRUE);
+ }
+ else{
+ HLTFatal("No mode set for clusterfindercomponent");
+ }
+
+ if(fClusterDeconv){
+ fClusterFinder->SetOccupancyLimit(1.0);
+ }
+
+ fClusterFinder->SetDeconv(fClusterDeconv);
+ fClusterFinder->SetDeconvPad(fDeconvPad);
+ fClusterFinder->SetDeconvTime(fDeconvPad);
+ fClusterFinder->SetXYError( fXYClusterError );
+ fClusterFinder->SetZError( fZClusterError );
+ if ( (fXYClusterError>0) && (fZClusterError>0) ){
+ fClusterFinder->SetCalcErr( false );
+ }
+
+ if(fFirstTimeBin>0){
+ fClusterFinder->SetFirstTimeBin(fFirstTimeBin);
+ }
+ if(fLastTimeBin>0 && fLastTimeBin>fFirstTimeBin && fLastTimeBin<=AliHLTTPCTransform::GetNTimeBins()){
+ fClusterFinder->SetLastTimeBin(fLastTimeBin);
+ }
+ fBenchmark.Reset();
+ fBenchmark.SetTimer(0,"total");
+ fBenchmark.SetTimer(1,"reco");
+
+ return iResult;
+}
+
+int AliHLTTPCClusterFinderComponent::DoDeinit()
+{
+ // see header file for class documentation
- fClusterFinder = new AliHLTTPCClusterFinder();
+ if ( fClusterFinder )
+ delete fClusterFinder;
+ fClusterFinder = NULL;
+
+ if ( fReader )
+ delete fReader;
+ fReader = NULL;
+
+ return 0;
+}
- Int_t rawreadermode = -1;
- Int_t sigthresh = -1;
- Float_t occulimit = 1.0;
+int AliHLTTPCClusterFinderComponent::DoEvent( const AliHLTComponentEventData& evtData,
+ const AliHLTComponentBlockData* blocks,
+ AliHLTComponentTriggerData& /*trigData*/, AliHLTUInt8_t* outputPtr,
+ AliHLTUInt32_t& size,
+ vector<AliHLTComponentBlockData>& outputBlocks )
+{
+ // see header file for class documentation
+ int iResult=0;
+ //SG!!!
+ //fDeconvTime = kTRUE;
+ //fClusterFinder->SetDeconvTime(fDeconvTime);
+ // fDeconvPad = kTRUE;
+ //fClusterFinder->SetDeconvPad(fDeconvPad);
+
+
+ fTS->SetCurrentTimeStamp(GetTimeStamp());
+ //fTS->SetCurrentTimeStamp(0);
+
+ if(fReader == NULL){
+ HLTFatal("Digit reader not initialized, skipping HLT TPC cluster reconstruction.");
+ size=0;
+ return -ENODEV;
+ }
+
+ if(!IsDataEvent()){
+ size=0;
+ return 0;
+ }
- // Data Format version numbers:
- // 0: RCU Data format as delivered during TPC commissioning, pads/padrows are sorted, RCU trailer is one 32 bit word.
- // 1: As 0, but pads/padrows are delivered "as is", without sorting
- // 2: As 0, but RCU trailer is 3 32 bit words.
- // 3: As 1, but RCU trailer is 3 32 bit words.
- // -1: use offline raw reader
+ fBenchmark.StartNewEvent();
+ fBenchmark.Start(0);
- Int_t i = 0;
- Char_t* cpErr;
+ // == init iter (pointer to datablock)
+ const AliHLTComponentBlockData* iter = NULL;
+ unsigned long ndx;
- while ( i < argc ) {
+ // == OUTdatatype pointer
+ AliHLTTPCClusterData* outPtr;
- // -- raw reader mode option
- if ( !strcmp( argv[i], "rawreadermode" ) ) {
- if ( argc <= i+1 ) {
- Logging( kHLTLogError, "HLT::TPCClusterFinder::DoInit", "Missing rawreadermode", "Raw Reader Mode not specified" );
- return ENOTSUP;
- }
-
- if ( !strcmp( argv[i+1], "sorted_1_trailerword" ) ) {
- rawreadermode = 0;
- }
- else if ( !strcmp( argv[i+1], "sorted_3_trailerword" ) ) {
- rawreadermode = 2;
- }
- else if ( !strcmp( argv[i+1], "unsorted_1_trailerword" ) ) {
- rawreadermode = 1;
- }
- else if ( !strcmp( argv[i+1], "unsorted_3_trailerword" ) ) {
- rawreadermode = 3;
- }
- else if ( !strcmp( argv[i+1], "offline" ) ) {
- rawreadermode = -1;
- }
- else {
- rawreadermode = strtoul( argv[i+1], &cpErr ,0);
- if ( *cpErr ) {
- Logging( kHLTLogError, "HLT::TPCClusterFinder::DoInit", "Missing rawreadermode", "Cannot convert rawreadermode specifier '%s'.", argv[i+1] );
- return EINVAL;
- }
- }
+ AliHLTUInt8_t* outBPtr;
+ UInt_t offset, mysize, nSize, tSize = 0;
+
+ outBPtr = outputPtr;
+ outPtr = (AliHLTTPCClusterData*)outBPtr;
+
+ Int_t slice, patch;
+ unsigned long maxPoints, realPoints = 0;
- i += 2;
+ for ( ndx = 0; ndx < evtData.fBlockCnt; ndx++ )
+ {
+ iter = blocks+ndx;
+ mysize = 0;
+ offset = tSize;
+
+ // Kenneth 16. July 2009
+ // 32 byte is the size of the common data header (CDH)
+ // this is introduced as a protection of empty files
+ // normally when running with file publisher where
+ // Timms script is used to create the missing files
+ if(iter->fSize <= 32){
continue;
}
- // -- pp run option
- if ( !strcmp( argv[i], "pp-run" ) ) {
- fClusterDeconv = false;
- i++;
- continue;
+
+ if (fModeSwitch==0 || fModeSwitch==2 || fModeSwitch==3) {
+ HLTDebug("Event 0x%08LX (%Lu) received datatype: %s - required datatype: %s",
+ evtData.fEventID, evtData.fEventID,
+ DataType2Text( iter->fDataType).c_str(),
+ DataType2Text(kAliHLTDataTypeDDLRaw | kAliHLTDataOriginTPC).c_str());
+
+ if (iter->fDataType == AliHLTTPCDefinitions::fgkDDLPackedRawDataType &&
+ GetEventCount()<2) {
+ HLTWarning("data type %s is depricated, use %s (kAliHLTDataTypeDDLRaw)!",
+ DataType2Text(AliHLTTPCDefinitions::fgkDDLPackedRawDataType).c_str(),
+ DataType2Text(kAliHLTDataTypeDDLRaw | kAliHLTDataOriginTPC).c_str());
+ }
+
+ if ( iter->fDataType != (kAliHLTDataTypeDDLRaw | kAliHLTDataOriginTPC) &&
+ iter->fDataType != AliHLTTPCDefinitions::fgkDDLPackedRawDataType ) continue;
+
}
+ else if(fModeSwitch==1){
+ HLTDebug("Event 0x%08LX (%Lu) received datatype: %s - required datatype: %s",
+ evtData.fEventID, evtData.fEventID,
+ DataType2Text( iter->fDataType).c_str(),
+ DataType2Text(AliHLTTPCDefinitions::fgkUnpackedRawDataType).c_str());
+
+ if ( iter->fDataType != AliHLTTPCDefinitions::fgkUnpackedRawDataType ) continue;
- // -- zero suppression threshold
- if ( !strcmp( argv[i], "adc-threshold" ) ) {
- sigthresh = strtoul( argv[i+1], &cpErr ,0);
- if ( *cpErr ) {
- HLTError("Cannot convert threshold specifier '%s'.", argv[i+1]);
- return EINVAL;
- }
- i+=2;
- continue;
}
- // -- pad occupancy limit
- if ( !strcmp( argv[i], "occupancy-threshold" ) ) {
- occulimit = strtof( argv[i+1], &cpErr);
- if ( *cpErr ) {
- HLTError("Cannot convert occupancy specifier '%s'.", argv[i+1]);
- return EINVAL;
- }
- i+=2;
- continue;
+ fBenchmark.AddInput(iter->fSize);
+
+ slice = AliHLTTPCDefinitions::GetMinSliceNr( *iter );
+ patch = AliHLTTPCDefinitions::GetMinPatchNr( *iter );
+
+ if(fUnsorted){
+ fClusterFinder->SetUnsorted(fUnsorted);
+ fClusterFinder->SetPatch(patch);
}
- Logging(kHLTLogError, "HLT::TPCClusterFinder::DoInit", "Unknown Option", "Unknown option '%s'", argv[i] );
- return EINVAL;
+ outPtr = (AliHLTTPCClusterData*)outBPtr;
- }
+ maxPoints = (size-tSize-sizeof(AliHLTTPCClusterData))/sizeof(AliHLTTPCSpacePointData);
- // Choose reader
-
- if (fPackedSwitch) {
- if (rawreadermode == -1) {
-#if defined(HAVE_ALIRAWDATA) && defined(HAVE_ALITPCRAWSTREAM_H)
- fReader = new AliHLTTPCDigitReaderPacked();
- fClusterFinder->SetReader(fReader);
-#else // ! defined(HAVE_ALIRAWDATA) && defined(HAVE_ALITPCRAWSTREAM_H)
- HLTFatal("DigitReaderPacked not available - check your build");
- return -ENODEV;
-#endif // defined(HAVE_ALIRAWDATA) && defined(HAVE_ALITPCRAWSTREAM_H)
- } else {
-#if defined(HAVE_TPC_MAPPING)
- fReader = new AliHLTTPCDigitReaderRaw(rawreadermode);
- fClusterFinder->SetReader(fReader);
-#else //! defined(HAVE_TPC_MAPPING)
- HLTFatal("DigitReaderRaw not available - check your build");
- return -ENODEV;
-#endif //defined(HAVE_TPC_MAPPING)
+ fClusterFinder->InitSlice( slice, patch, maxPoints );
+ fClusterFinder->SetOutputArray( (AliHLTTPCSpacePointData*)outPtr->fSpacePoints );
+
+ fBenchmark.Start(1);
+
+ if(fUnsorted){
+ if(fGetActivePads){
+ fClusterFinder->SetDoPadSelection(kTRUE);
+ }
+ if(fDeconvTime){
+ fClusterFinder->ReadDataUnsortedDeconvoluteTime(iter->fPtr, iter->fSize);
+ }
+ else{
+ fClusterFinder->ReadDataUnsorted(iter->fPtr, iter->fSize);
+ }
+
+ fClusterFinder->FindClusters();
}
- }
- else {
- fReader = new AliHLTTPCDigitReaderUnpacked();
- fClusterFinder->SetReader(fReader);
- }
+ else{
+ fClusterFinder->Read(iter->fPtr, iter->fSize );
+ fClusterFinder->ProcessDigits();
+ }
+ fBenchmark.Stop(1);
- // if pp-run use occupancy limit else set to 1. ==> use all
- if ( !fClusterDeconv )
- fClusterFinder->SetOccupancyLimit(occulimit);
- else
- fClusterFinder->SetOccupancyLimit(1.0);
-
- // Variables to setup the Clusterfinder
- // TODO: this sounds strange and has to be verified; is the cluster finder not working when
- // fClusterDeconv = false ?
- fClusterDeconv = true;
- fXYClusterError = -1;
- fZClusterError = -1;
+ fReader->Reset();
-
- fClusterFinder->SetDeconv( fClusterDeconv );
- fClusterFinder->SetXYError( fXYClusterError );
- fClusterFinder->SetZError( fZClusterError );
- if ( (fXYClusterError>0) && (fZClusterError>0) )
- fClusterFinder->SetCalcErr( false );
- fClusterFinder->SetSignalThreshold(sigthresh);
-
- return 0;
- }
+ realPoints = fClusterFinder->GetNumberOfClusters();
+
+ outPtr->fSpacePointCnt = realPoints;
+ nSize = sizeof(AliHLTTPCSpacePointData)*realPoints;
+ mysize += nSize+sizeof(AliHLTTPCClusterData);
+
+ Logging( kHLTLogDebug, "HLT::TPCClusterFinder::DoEvent", "Spacepoints",
+ "Number of spacepoints: %lu Slice/Patch/RowMin/RowMax: %d/%d/%d/%d.",
+ realPoints, slice, patch,AliHLTTPCTransform::GetFirstRow( patch ) , AliHLTTPCTransform::GetLastRow( patch ) );
+ AliHLTComponentBlockData bd;
+ FillBlockData( bd );
+ bd.fOffset = offset;
+ bd.fSize = mysize;
+ bd.fSpecification = iter->fSpecification;
+ bd.fDataType = AliHLTTPCDefinitions::fgkClustersDataType;
+ outputBlocks.push_back( bd );
+
+ fBenchmark.AddOutput(bd.fSize);
+
+ tSize += mysize;
+ outBPtr += mysize;
+ outPtr = (AliHLTTPCClusterData*)outBPtr;
+
-int AliHLTTPCClusterFinderComponent::DoDeinit()
- {
+ if ( tSize > size )
+ {
+ Logging( kHLTLogFatal, "HLT::TPCClusterFinder::DoEvent", "Too much data",
+ "Data written over allowed buffer. Amount written: %lu, allowed amount: %lu.",
+ tSize, size );
+ iResult=-ENOSPC;
+ break;
+ }
+
+ if(fUnsorted && fGetActivePads){
+ Int_t maxNumberOfHW=(Int_t)((size-tSize)/sizeof(AliHLTUInt16_t)-1);
+ AliHLTUInt16_t* outputHWPtr= (AliHLTUInt16_t*)(outputPtr+tSize);
+ Int_t nHWAdd = fClusterFinder->FillHWAddressList(outputHWPtr, maxNumberOfHW);
+
+ AliHLTComponentBlockData bdHW;
+ FillBlockData( bdHW );
+ bdHW.fOffset = tSize ;
+ bdHW.fSize = nHWAdd*sizeof(AliHLTUInt16_t);
+ bdHW.fSpecification = iter->fSpecification;
+ bdHW.fDataType = kAliHLTDataTypeHwAddr16;
+ outputBlocks.push_back( bdHW );
+
+ fBenchmark.AddOutput(bdHW.fSize);
+ tSize+=nHWAdd*sizeof(AliHLTUInt16_t);
+ }
- if ( fClusterFinder )
- delete fClusterFinder;
- fClusterFinder = NULL;
-
- if ( fReader )
- delete fReader;
- fReader = NULL;
-
- return 0;
- }
+ /*
+ { // compressed output for the CA tracker
-int AliHLTTPCClusterFinderComponent::DoEvent( const AliHLTComponent_EventData& evtData,
- const AliHLTComponent_BlockData* blocks,
- AliHLTComponent_TriggerData& trigData, AliHLTUInt8_t* outputPtr,
- AliHLTUInt32_t& size,
- vector<AliHLTComponent_BlockData>& outputBlocks )
- {
+ AliHLTUInt32_t dSize = 0;
- // == init iter (pointer to datablock)
- const AliHLTComponent_BlockData* iter = NULL;
- unsigned long ndx;
+ int ret = AliHLTTPCCAInputDataCompressorComponent::Compress( (AliHLTTPCClusterData*)( outputPtr + bd.fOffset ),
+ size - tSize,
+ outputPtr+tSize,
+ dSize );
+
+ if ( ret!=0 || tSize + dSize > size )
+ {
+ Logging( kHLTLogFatal, "HLT::TPCClusterFinder::DoEvent", "Too much data",
+ "Data written over allowed buffer. Amount written: %lu, allowed amount: %lu.",
+ tSize + dSize, size );
+ iResult=-ENOSPC;
+ break;
+ }
+
+ AliHLTComponentBlockData bdCompressed;
+ FillBlockData( bdCompressed );
+ bdCompressed.fOffset = tSize ;
+ bdCompressed.fSize = dSize;
+ bdCompressed.fSpecification = iter->fSpecification;
+ bdCompressed.fDataType = AliHLTTPCCADefinitions::fgkCompressedInputDataType;
+ outputBlocks.push_back( bdCompressed );
+
+ tSize += dSize;
+ outBPtr += dSize;
+ outPtr = (AliHLTTPCClusterData*)outBPtr;
+ }
+ */
- // == OUTdatatype pointer
- AliHLTTPCClusterData* outPtr;
+ if(fDoMC){
+ Int_t maxNumberOfClusterMCInfo = (Int_t)((size-tSize)/sizeof(AliHLTTPCClusterFinder::ClusterMCInfo)-1);
+ AliHLTTPCClusterFinder::ClusterMCInfo* outputMCInfo= (AliHLTTPCClusterFinder::ClusterMCInfo*)(outputPtr+tSize);
+ Int_t nMCInfo = fClusterFinder->FillOutputMCInfo(outputMCInfo, maxNumberOfClusterMCInfo);
+
+ AliHLTComponentBlockData bdMCInfo;
+ FillBlockData( bdMCInfo );
+ bdMCInfo.fOffset = tSize ;
+ bdMCInfo.fSize = nMCInfo*sizeof(AliHLTTPCClusterFinder::ClusterMCInfo);
+ bdMCInfo.fSpecification = iter->fSpecification;
+ bdMCInfo.fDataType = AliHLTTPCDefinitions::fgkAliHLTDataTypeClusterMCInfo;
+ outputBlocks.push_back( bdMCInfo );
+ fBenchmark.AddOutput(bdMCInfo.fSize);
- AliHLTUInt8_t* outBPtr;
- UInt_t offset, mysize, nSize, tSize = 0;
+ tSize+=nMCInfo*sizeof(AliHLTTPCClusterFinder::ClusterMCInfo);
- outBPtr = outputPtr;
- outPtr = (AliHLTTPCClusterData*)outBPtr;
+ }
+ }
- Int_t slice, patch, row[2];
- unsigned long maxPoints, realPoints = 0;
+ if (iResult>=0)
+ size = tSize;
- for ( ndx = 0; ndx < evtData.fBlockCnt; ndx++ )
- {
- iter = blocks+ndx;
- mysize = 0;
- offset = tSize;
+ fBenchmark.Stop(0);
+ HLTInfo(fBenchmark.GetStatistics());
+ return iResult;
+}
+int AliHLTTPCClusterFinderComponent::ScanConfigurationArgument(int argc, const char** argv){
- if (fPackedSwitch) {
- char tmp1[14], tmp2[14];
- DataType2Text( iter->fDataType, tmp1 );
- DataType2Text( AliHLTTPCDefinitions::gkDDLPackedRawDataType, tmp2 );
- Logging( kHLTLogDebug, "HLT::TPCClusterFinder::DoEvent", "Event received",
- "Event 0x%08LX (%Lu) received datatype: %s - required datatype: %s",
- evtData.fEventID, evtData.fEventID, tmp1, tmp2 );
+ // see header file for class documentation
- if ( iter->fDataType != AliHLTTPCDefinitions::gkDDLPackedRawDataType ) continue;
+ if (argc<=0) return 0;
+ int i=0;
+ TString argument=argv[i];
- }
- else {
- char tmp1[14], tmp2[14];
- DataType2Text( iter->fDataType, tmp1 );
- DataType2Text( AliHLTTPCDefinitions::gkUnpackedRawDataType, tmp2 );
- Logging( kHLTLogDebug, "HLT::TPCClusterFinder::DoEvent", "Event received",
- "Event 0x%08LX (%Lu) received datatype: %s - required datatype: %s",
- evtData.fEventID, evtData.fEventID, tmp1, tmp2 );
+ if (argument.CompareTo("-solenoidBz")==0){
+ if (++i>=argc) return -EPROTO;
+ HLTWarning("argument -solenoidBz is deprecated, magnetic field set up globally (%f)", GetBz());
+ return 2;
+ }
- if ( iter->fDataType != AliHLTTPCDefinitions::gkUnpackedRawDataType ) continue;
+ if (argument.CompareTo("-update-calibdb")==0 || argument.CompareTo("-update-transform")==0 ){
+ if(fClusterFinder->UpdateCalibDB()){
+ HLTDebug("CalibDB and offline transform successfully updated.");
+ }
+ else{
+ HLTError("CalibDB could not be updated.");
+ }
+ return 1;
+ }
+
+ if (argument.CompareTo("-deconvolute-time")==0){
+ HLTDebug("Switching on deconvolution in time direction.");
+ fDeconvTime = kTRUE;
+ fClusterFinder->SetDeconvTime(fDeconvTime);
+ return 1;
+ }
+
+ if (argument.CompareTo("-deconvolute-pad")==0){
+ HLTDebug("Switching on deconvolution in pad direction.");
+ fDeconvPad = kTRUE;
+ fClusterFinder->SetDeconvPad(fDeconvPad);
+ return 1;
+ }
+
+ if (argument.CompareTo("-timebins")==0 || argument.CompareTo("timebins" )==0){
+ HLTWarning("Argument %s is depreciated after moving to the offline AliTPCTransform class for xyz calculations.",argument.Data());
+ /*
+ if (++i>=argc) return -EPROTO;
+ argument=argv[i];
+ AliHLTTPCTransform::SetNTimeBins(argument.Atoi());
+ fClusterFinder->UpdateLastTimeBin();
+ HLTInfo("number of timebins set to %d, zbin=%f", AliHLTTPCTransform::GetNTimeBins(), AliHLTTPCTransform::GetZWidth());
+ return 2;
+ */
+ if(argument.CompareTo("timebins")==0){
+ HLTWarning("Argument 'timebins' is old, please switch to new argument naming convention (-timebins). The timebins argument will still work, but please change anyway.");
+ }
+ return 2;
+ }
+
+ if (argument.CompareTo("-first-timebin")==0){
+ if (++i>=argc) return -EPROTO;
+ argument=argv[i];
+ fFirstTimeBin = argument.Atoi();
+ if(fFirstTimeBin>=0){
+ HLTDebug("fFirstTimeBin set to %d",fFirstTimeBin);
+ fClusterFinder->SetFirstTimeBin(fFirstTimeBin);
+ }
+ else{
+ HLTError("-first-timebin specifier is negative: %d",fFirstTimeBin);
+ }
+ return 2;
+ }
+
+ if (argument.CompareTo("-last-timebin")==0){
+ if (++i>=argc) return -EPROTO;
+ argument=argv[i];
+ fLastTimeBin = argument.Atoi();
+ if(fLastTimeBin<AliHLTTPCTransform::GetNTimeBins()){
+ HLTDebug("fLastTimeBin set to %d",fLastTimeBin);
+ }
+ else{
+ HLTError("fLastTimeBins is too big: %d. Maximum: %d",fLastTimeBin,AliHLTTPCTransform::GetNTimeBins());
+ }
+ return 2;
+ }
+
+ if (argument.CompareTo("-sorted")==0) {
+ fUnsorted=0;
+ HLTDebug("Swithching unsorted off.");
+ fClusterFinder->SetUnsorted(0);
+ return 1;
+ }
+
+ if (argument.CompareTo("-do-mc")==0) {
+ fDoMC=kTRUE;
+ fClusterFinder->SetDoMC(fDoMC);
+ HLTDebug("Setting fDoMC to true.");
+ return 1;
+ }
+ if (argument.CompareTo("-release-memory")==0) {
+ fReleaseMemory=kTRUE;
+ fClusterFinder->SetReleaseMemory( fReleaseMemory );
+ HLTDebug("Setting fReleaseMemory to true.");
+ return 1;
+ }
+
+ if (argument.CompareTo("-active-pads")==0 || argument.CompareTo("activepads")==0){
+ if(argument.CompareTo("activepads" )==0){
+ HLTWarning("Please change to new component argument naming scheme and use '-active-pads' instead of 'activepads'");
+ }
+ HLTDebug("Switching on ActivePads");
+ fGetActivePads = 1;
+ fClusterFinder->SetDoPadSelection(kTRUE);
+ return 1;
+ }
+
+ if (argument.CompareTo("-occupancy-limit")==0 || argument.CompareTo("occupancy-limit")==0){
+ if(argument.CompareTo("occupancy-limit" )==0){
+ HLTWarning("Please switch to new component argument naming convention, use '-occupancy-limit' instead of 'occupancy-limit'");
+ }
+ if (++i>=argc) return -EPROTO;
+ argument=argv[i];
+ fClusterFinder->SetOccupancyLimit(argument.Atof());
+ HLTDebug("Occupancy limit set to occulimit %f", argument.Atof());
+ return 2;
+ }
+
+ if (argument.CompareTo("rawreadermode")==0){
+ if (++i>=argc) return -EPROTO;
+ HLTWarning("Argument 'rawreadermode' is deprecated");
+ return 2;
+ }
+
+ if (argument.CompareTo("pp-run")==0){
+ HLTWarning("Argument 'pp-run' is obsolete, deconvolution is swiched off in both time and pad directions by default.");
+ fClusterDeconv = false;
+ return 1;
+ }
+
+ if (argument.CompareTo("adc-threshold" )==0){
+ if (++i>=argc) return -EPROTO;
+ HLTWarning("'adc-threshold' is no longer a valid argument, please use TPCZeroSuppression component if you want to zerosuppress data.");
+ return 2;
+ }
+
+ if (argument.CompareTo("oldrcuformat" )==0){
+ if (++i>=argc) return -EPROTO;
+ HLTWarning("Argument 'oldrcuformat' is deprecated.");
+ return 2;
+ }
+
+ if (argument.CompareTo("unsorted" )==0 || argument.CompareTo("-unsorted" )==0){
+ HLTWarning("Argument is obsolete, unsorted reading is default.");
+ // fClusterFinder->SetUnsorted(1);
+ return 1;
+ }
+ if (argument.CompareTo("nsigma-threshold")==0){
+ if (++i>=argc) return -EPROTO;
+ HLTWarning("Argument 'nsigma-threshold' argument is obsolete.");
+ return 2;
+ }
+
+ // unknown argument
+ return -EINVAL;
+}
- }
-
- slice = AliHLTTPCDefinitions::GetMinSliceNr( *iter );
- patch = AliHLTTPCDefinitions::GetMinPatchNr( *iter );
- row[0] = AliHLTTPCTransform::GetFirstRow( patch );
- row[1] = AliHLTTPCTransform::GetLastRow( patch );
-
- Logging( kHLTLogDebug, "HLT::TPCClusterFinder::DoEvent", "Input Spacepoints",
- "Input: Number of spacepoints: %lu Slice/Patch/RowMin/RowMax: %d/%d/%d/%d.",
- realPoints, slice, patch, row[0], row[1] );
-
- outPtr = (AliHLTTPCClusterData*)outBPtr;
+int AliHLTTPCClusterFinderComponent::Reconfigure(const char* cdbEntry, const char* /*chainId*/)
+{
+ // see header file for class documentation
+
+ TString cdbPath;
+ if (cdbEntry) {
+ cdbPath=cdbEntry;
+ } else {
+ cdbPath="HLT/ConfigTPC/";
+ cdbPath+=GetComponentID();
+ }
+
+ return ConfigureFromCDBTObjString(cdbPath.Data());
+
+ /*
+ int iResult=0;
+
+ const char* path="HLT/ConfigTPC/ClusterFinderComponent";
+ if (cdbEntry) path=cdbEntry;
+ if (path) {
+ HLTInfo("reconfigure from entry %s, chain id %s", path, (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) {
+ HLTInfo("received configuration object: %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;
+ */
+}
- maxPoints = (size-tSize-sizeof(AliHLTTPCClusterData))/sizeof(AliHLTTPCSpacePointData);
+int AliHLTTPCClusterFinderComponent::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();
- fClusterFinder->InitSlice( slice, patch, row[0], row[1], maxPoints );
- fClusterFinder->SetOutputArray( outPtr->fSpacePoints );
- fClusterFinder->Read(iter->fPtr, iter->fSize );
- fClusterFinder->ProcessDigits();
- realPoints = fClusterFinder->GetNumberOfClusters();
-
- Logging( kHLTLogDebug, "HLT::TPCClusterFinder::DoEvent", "Spacepoints",
- "Number of spacepoints found: %lu.", realPoints );
-
- outPtr->fSpacePointCnt = realPoints;
- nSize = sizeof(AliHLTTPCSpacePointData)*realPoints;
- mysize += nSize+sizeof(AliHLTTPCClusterData);
-
- Logging( kHLTLogDebug, "HLT::TPCClusterFinder::DoEvent", "Input Spacepoints",
- "Number of spacepoints: %lu Slice/Patch/RowMin/RowMax: %d/%d/%d/%d.",
- realPoints, slice, patch, row[0], row[1] );
- AliHLTComponent_BlockData bd;
- FillBlockData( bd );
- bd.fOffset = offset;
- bd.fSize = mysize;
- bd.fSpecification = iter->fSpecification;
- //AliHLTSubEventDescriptor::FillBlockAttributes( bd.fAttributes );
- outputBlocks.push_back( bd );
-
- tSize += mysize;
- outBPtr += mysize;
- outPtr = (AliHLTTPCClusterData*)outBPtr;
+ if (argument.IsNull()) continue;
+
+ // -- deconvolute-time option
+ if (argument.CompareTo("-deconvolute-time")==0){
+ HLTDebug("Switching on deconvolution in time direction.");
+ fDeconvTime = kTRUE;
+ fClusterFinder->SetDeconvTime(fDeconvTime);
+ }
+ else if (argument.CompareTo("-deconvolute-pad")==0){
+ HLTDebug("Switching on deconvolution in pad direction.");
+ fDeconvPad = kTRUE;
+ fClusterFinder->SetDeconvPad(fDeconvPad);
+ }
+ else if (argument.CompareTo("-timebins")==0 || argument.CompareTo("timebins" )==0){
+ HLTWarning("Argument %s is depreciated after moving to the offline AliTPCTransform class for xyz calculations.",argument.Data());
+ /*
+ if ((bMissingParam=(++i>=pTokens->GetEntries()))) break;
+ AliHLTTPCTransform::SetNTimeBins(((TObjString*)pTokens->At(i))->GetString().Atoi());
+ fClusterFinder->UpdateLastTimeBin();
+ HLTInfo("number of timebins set to %d, zbin=%f", AliHLTTPCTransform::GetNTimeBins(), AliHLTTPCTransform::GetZWidth());
+ */
+ if(argument.CompareTo("timebins")==0){
+ HLTWarning("Argument 'timebins' is old, please switch to new argument naming convention (-timebins). The timebins argument will still work, but please change anyway.");
+ }
- if ( tSize > size )
- {
- Logging( kHLTLogFatal, "HLT::TPCClusterFinder::DoEvent", "Too much data",
- "Data written over allowed buffer. Amount written: %lu, allowed amount: %lu.",
- tSize, size );
- return EMSGSIZE;
- }
+ }
+ else if (argument.CompareTo("-first-timebin")==0){
+ if ((bMissingParam=(++i>=pTokens->GetEntries()))) break;
+ fFirstTimeBin = ((TObjString*)pTokens->At(i))->GetString().Atoi();
+ if(fFirstTimeBin>=0){
+ HLTDebug("fFirstTimeBin set to %d",fFirstTimeBin);
+ fClusterFinder->SetFirstTimeBin(fFirstTimeBin);
}
-
- size = tSize;
-
- return 0;
+ else{
+ HLTError("-first-timebin specifier is negative: %d",fFirstTimeBin);
+ }
+ }
+ else if (argument.CompareTo("-last-timebin")==0){
+ if ((bMissingParam=(++i>=pTokens->GetEntries()))) break;
+ fLastTimeBin = ((TObjString*)pTokens->At(i))->GetString().Atoi();
+ if(fLastTimeBin<AliHLTTPCTransform::GetNTimeBins()){
+ HLTDebug("fLastTimeBin set to %d",fLastTimeBin);
+ }
+ else{
+ HLTError("fLastTimeBins is too big: %d. Maximum: %d",fLastTimeBin,AliHLTTPCTransform::GetNTimeBins());
+ }
+ }
+ else if (argument.CompareTo("-sorted")==0) {
+ fUnsorted=0;
+ HLTDebug("Swithching unsorted off.");
+ fClusterFinder->SetUnsorted(0);
+ }
+ else if (argument.CompareTo("-do-mc")==0) {
+ fDoMC=kTRUE;
+ fClusterFinder->SetDoMC(fDoMC);
+ HLTInfo("Setting fDoMC to true.");
+ }
+ else if (argument.CompareTo("-release-memory")==0) {
+ fReleaseMemory = kTRUE;
+ fClusterFinder->SetReleaseMemory( kTRUE );
+ HLTInfo("Setting fReleaseMemory to true.");
+ }
+ else if (argument.CompareTo("-active-pads")==0 || argument.CompareTo("activepads")==0){
+ if(argument.CompareTo("activepads" )==0){
+ HLTWarning("Please change to new component argument naming scheme and use '-active-pads' instead of 'activepads'");
+ }
+ HLTDebug("Switching on ActivePads");
+ fGetActivePads = 1;
+ fClusterFinder->SetDoPadSelection(kTRUE);
+ }
+ else if (argument.CompareTo("-occupancy-limit")==0 || argument.CompareTo("occupancy-limit")==0){
+ if(argument.CompareTo("occupancy-limit" )==0){
+ HLTWarning("Please switch to new component argument naming convention, use '-occupancy-limit' instead of 'occupancy-limit'");
+ }
+ if ((bMissingParam=(++i>=pTokens->GetEntries()))) break;
+ fClusterFinder->SetOccupancyLimit(((TObjString*)pTokens->At(i))->GetString().Atof());
+ HLTDebug("Occupancy limit set to occulimit %f", ((TObjString*)pTokens->At(i))->GetString().Atof());
+ }
+ else if (argument.CompareTo("rawreadermode")==0){
+ if ((bMissingParam=(++i>=pTokens->GetEntries()))) break;
+ HLTWarning("Argument 'rawreadermode' is deprecated");
+ }
+ else if (argument.CompareTo("pp-run")==0){
+ HLTWarning("Argument 'pp-run' is obsolete, deconvolution is swiched off in both time and pad directions by default.");
+ fClusterDeconv = false;
+ }
+ else if (argument.CompareTo("adc-threshold" )==0){
+ if ((bMissingParam=(++i>=pTokens->GetEntries()))) break;
+ HLTWarning("'adc-threshold' is no longer a valid argument, please use TPCZeroSuppression component if you want to zerosuppress data.");
+ }
+ else if (argument.CompareTo("oldrcuformat" )==0){
+ if ((bMissingParam=(++i>=pTokens->GetEntries()))) break;
+ HLTWarning("Argument 'oldrcuformat' is deprecated.");
+ }
+ else if (argument.CompareTo("unsorted" )==0){
+ if ((bMissingParam=(++i>=pTokens->GetEntries()))) break;
+ HLTDebug("Using unsorted reading.");
+ fClusterFinder->SetUnsorted(1);
+ }
+ else if (argument.CompareTo("nsigma-threshold")==0){
+ if ((bMissingParam=(++i>=pTokens->GetEntries()))) break;
+ HLTWarning("Argument 'nsigma-threshold' argument is obsolete.");
+ }
+ else if (argument.CompareTo("-update-calibdb")==0){
+ fClusterFinder->UpdateCalibDB();
+ }
+ 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;
+}
-
+void AliHLTTPCClusterFinderComponent::GetOCDBObjectDescription( TMap* const targetMap){
+// Get a list of OCDB object description needed for the particular component
+
+ if (!targetMap) return;
+
+ // OCDB entries for component arguments
+ targetMap->Add(new TObjString("HLT/ConfigTPC/TPCClusterFinder32Bit"), new TObjString("component arguments, empty at the moment"));
+ targetMap->Add(new TObjString("HLT/ConfigTPC/TPCClusterFinderPacked"), new TObjString("component arguments, empty at the moment"));
+ targetMap->Add(new TObjString("HLT/ConfigTPC/TPCClusterFinderUnpacked"), new TObjString("component arguments, empty at the moment"));
+ targetMap->Add(new TObjString("HLT/ConfigTPC/TPCClusterFinderDecoder"), new TObjString("component arguments, empty at the moment"));
+
+ // OCDB entries to be fetched by the TAXI (access via the AliTPCcalibDB class)
+ targetMap->Add(new TObjString("TPC/Calib/Parameters"), new TObjString("unknown content"));
+ targetMap->Add(new TObjString("TPC/Calib/TimeDrift"), new TObjString("drift velocity calibration"));
+ targetMap->Add(new TObjString("TPC/Calib/Temperature"), new TObjString("temperature map"));
+ targetMap->Add(new TObjString("TPC/Calib/PadGainFactor"), new TObjString("gain factor pad by pad"));
+ targetMap->Add(new TObjString("TPC/Calib/ClusterParam"), new TObjString("cluster parameters"));
+
+ // OCDB entries needed to be fetched by the Pendolino
+ targetMap->Add(new TObjString("TPC/Calib/AltroConfig"), new TObjString("contains the altro config, e.g. info about the L0 trigger timing"));
+ targetMap->Add(new TObjString("GRP/CTP/CTPtiming"), new TObjString("content used in the cluster coordinate transformation in relation to the L0 trigger timing"));
+
+ // OCDB entries necessary for replaying data on the HLT cluster
+ targetMap->Add(new TObjString("GRP/GRP/Data"), new TObjString("contains magnetic field info"));
+
+ // OCDB entries needed to suppress fatals/errors/warnings during reconstruction
+ targetMap->Add(new TObjString("TPC/Calib/PadTime0"), new TObjString("time0 offset pad by pad"));
+ targetMap->Add(new TObjString("TPC/Calib/PadNoise"), new TObjString("pad noise values"));
+ targetMap->Add(new TObjString("TPC/Calib/Pedestals"), new TObjString("pedestal info"));
+ targetMap->Add(new TObjString("TPC/Calib/Pulser"), new TObjString("pulser info"));
+ targetMap->Add(new TObjString("TPC/Calib/CE"), new TObjString("CE laser calibration result"));
+ targetMap->Add(new TObjString("TPC/Calib/Raw"), new TObjString("unknown content"));
+ targetMap->Add(new TObjString("TPC/Calib/QA"), new TObjString("not important"));
+ targetMap->Add(new TObjString("TPC/Calib/Mapping"), new TObjString("unknown content"));
+ targetMap->Add(new TObjString("TPC/Calib/Goofie"), new TObjString("Goofie values, not used at the moment (05.03.2010)"));
+ targetMap->Add(new TObjString("TPC/Calib/HighVoltage"), new TObjString("high voltage values, not used"));
+ targetMap->Add(new TObjString("TPC/Calib/Ref"), new TObjString("unknown content"));
+}