X-Git-Url: http://git.uio.no/git/?a=blobdiff_plain;f=HLT%2FTPCLib%2FAliHLTTPCClusterFinderComponent.cxx;h=ad42f5ec5e0a4431c92a68f4d5c146ff938ae070;hb=80dbd4f73940088a6feb734b8eaac0a078375a12;hp=4e8fb5ce3d029dd1ab7418cadb8ca52f70640eb8;hpb=998bd503cb0984919e60189485a4fb8b352287e9;p=u%2Fmrichter%2FAliRoot.git diff --git a/HLT/TPCLib/AliHLTTPCClusterFinderComponent.cxx b/HLT/TPCLib/AliHLTTPCClusterFinderComponent.cxx index 4e8fb5ce3d0..ad42f5ec5e0 100644 --- a/HLT/TPCLib/AliHLTTPCClusterFinderComponent.cxx +++ b/HLT/TPCLib/AliHLTTPCClusterFinderComponent.cxx @@ -23,21 +23,26 @@ @brief The TPC cluster finder processing component */ -#if __GNUC__>= 3 -using namespace std; -#endif #include "AliHLTTPCClusterFinderComponent.h" -#include "AliHLTTPCDigitReaderPacked.h" #include "AliHLTTPCDigitReaderUnpacked.h" -#include "AliHLTTPCDigitReaderDecoder.h" +#include "AliHLTTPCDigitReader32Bit.h" #include "AliHLTTPCClusterFinder.h" #include "AliHLTTPCSpacePointData.h" #include "AliHLTTPCClusterDataFormat.h" #include "AliHLTTPCTransform.h" #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 "AliHLTTPCClusterMCData.h" + +//#include "AliHLTTPCCAInputDataCompressorComponent.h" +//#include "AliHLTTPCCADef.h" #include #include @@ -47,9 +52,13 @@ using namespace std; #include "AliCDBEntry.h" #include "AliCDBManager.h" #include "AliCDBStorage.h" +#include "TGeoGlobalMagField.h" +#include "AliGeomManager.h" #include +using namespace std; + /** ROOT macro for the implementation of ROOT specific class methods */ ClassImp(AliHLTTPCClusterFinderComponent) @@ -58,6 +67,7 @@ AliHLTTPCClusterFinderComponent::AliHLTTPCClusterFinderComponent(int mode) fClusterFinder(NULL), fReader(NULL), fDeconvTime(kFALSE), + fTS(0), fDeconvPad(kFALSE), fClusterDeconv(false), fXYClusterError(-1), @@ -67,7 +77,11 @@ AliHLTTPCClusterFinderComponent::AliHLTTPCClusterFinderComponent(int mode) fPatch(0), fGetActivePads(0), fFirstTimeBin(-1), - fLastTimeBin(-1) + fLastTimeBin(-1), + fDoMC(kFALSE), + fReleaseMemory( kFALSE ), + fPublishRawClusters(kFALSE), + fBenchmark("TPCClusterFinder") { // see header file for class documentation // or @@ -76,7 +90,8 @@ AliHLTTPCClusterFinderComponent::AliHLTTPCClusterFinderComponent(int mode) // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt if (fModeSwitch!=kClusterFinderPacked && fModeSwitch!=kClusterFinderUnpacked && - fModeSwitch!=kClusterFinderDecoder) { + fModeSwitch!=kClusterFinderDecoder && + fModeSwitch!=kClusterFinder32Bit) { HLTFatal("unknown digit reader type"); } } @@ -102,6 +117,9 @@ const char* AliHLTTPCClusterFinderComponent::GetComponentID() case kClusterFinderDecoder: return "TPCClusterFinderDecoder"; break; + case kClusterFinder32Bit: + return "TPCClusterFinder32Bit"; + break; } return ""; } @@ -111,13 +129,12 @@ void AliHLTTPCClusterFinderComponent::GetInputDataTypes( vectorGetTransform(); + + 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(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=""; @@ -185,6 +256,7 @@ int AliHLTTPCClusterFinderComponent::DoInit( int argc, const char** argv ) } else { iResult=Reconfigure(NULL, NULL); } + */ //Checking for conflicting arguments if(fClusterDeconv){ @@ -202,20 +274,25 @@ int AliHLTTPCClusterFinderComponent::DoInit( int argc, const char** argv ) // Choose reader if (fModeSwitch==kClusterFinderPacked) { - HLTDebug("using AliHLTTPCDigitReaderPacked"); - fReader = new AliHLTTPCDigitReaderPacked(); - if(fUnsorted==1){ fReader->SetUnsorted(kTRUE); } - fClusterFinder->SetReader(fReader); + HLTWarning("AliHLTTPCDigitReaderPacked is deprecated, falling back to AliHLTTPCDigitReader32Bit"); + } + else if(fModeSwitch==kClusterFinderDecoder){ + HLTWarning("AliHLTTPCDigitReaderPacked is deprecated, falling back to AliHLTTPCDigitReader32Bit"); } - else if(fModeSwitch==kClusterFinderUnpacked){ + + 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(); + } + else if(fModeSwitch==kClusterFinder32Bit || + fModeSwitch==kClusterFinderPacked || + fModeSwitch==kClusterFinderDecoder){ + HLTDebug("using AliHLTTPCDigitReader32Bit"); + fReader = new AliHLTTPCDigitReader32Bit(); fClusterFinder->SetReader(fReader); + fClusterFinder->Set32BitFormat(kTRUE); } else{ HLTFatal("No mode set for clusterfindercomponent"); @@ -240,8 +317,11 @@ int AliHLTTPCClusterFinderComponent::DoInit( int argc, const char** argv ) if(fLastTimeBin>0 && fLastTimeBin>fFirstTimeBin && fLastTimeBin<=AliHLTTPCTransform::GetNTimeBins()){ fClusterFinder->SetLastTimeBin(fLastTimeBin); } + fBenchmark.Reset(); + fBenchmark.SetTimer(0,"total"); + fBenchmark.SetTimer(1,"reco"); - return 0; + return iResult; } int AliHLTTPCClusterFinderComponent::DoDeinit() @@ -266,18 +346,31 @@ int AliHLTTPCClusterFinderComponent::DoEvent( const AliHLTComponentEventData& ev vector& 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 0; + return -ENODEV; } - if(GetFirstInputBlock( kAliHLTDataTypeSOR ) || GetFirstInputBlock( kAliHLTDataTypeEOR )){ + if(!IsDataEvent()){ size=0; return 0; } + fBenchmark.StartNewEvent(); + fBenchmark.Start(0); + // == init iter (pointer to datablock) const AliHLTComponentBlockData* iter = NULL; unsigned long ndx; @@ -300,22 +393,23 @@ int AliHLTTPCClusterFinderComponent::DoEvent( const AliHLTComponentEventData& ev 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; + } + - if (fModeSwitch==0 || fModeSwitch==2) { + 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; + if ( iter->fDataType != (kAliHLTDataTypeDDLRaw | kAliHLTDataOriginTPC)) continue; } else if(fModeSwitch==1){ @@ -328,6 +422,8 @@ int AliHLTTPCClusterFinderComponent::DoEvent( const AliHLTComponentEventData& ev } + fBenchmark.AddInput(iter->fSize); + slice = AliHLTTPCDefinitions::GetMinSliceNr( *iter ); patch = AliHLTTPCDefinitions::GetMinPatchNr( *iter ); @@ -340,9 +436,12 @@ int AliHLTTPCClusterFinderComponent::DoEvent( const AliHLTComponentEventData& ev maxPoints = (size-tSize-sizeof(AliHLTTPCClusterData))/sizeof(AliHLTTPCSpacePointData); + fClusterFinder->SetFillRawClusters(fPublishRawClusters); fClusterFinder->InitSlice( slice, patch, maxPoints ); fClusterFinder->SetOutputArray( (AliHLTTPCSpacePointData*)outPtr->fSpacePoints ); + fBenchmark.Start(1); + if(fUnsorted){ if(fGetActivePads){ fClusterFinder->SetDoPadSelection(kTRUE); @@ -360,6 +459,9 @@ int AliHLTTPCClusterFinderComponent::DoEvent( const AliHLTComponentEventData& ev fClusterFinder->Read(iter->fPtr, iter->fSize ); fClusterFinder->ProcessDigits(); } + fBenchmark.Stop(1); + + fReader->Reset(); realPoints = fClusterFinder->GetNumberOfClusters(); @@ -377,7 +479,9 @@ int AliHLTTPCClusterFinderComponent::DoEvent( const AliHLTComponentEventData& ev bd.fSpecification = iter->fSpecification; bd.fDataType = AliHLTTPCDefinitions::fgkClustersDataType; outputBlocks.push_back( bd ); - + + fBenchmark.AddOutput(bd.fSize); + tSize += mysize; outBPtr += mysize; outPtr = (AliHLTTPCClusterData*)outBPtr; @@ -388,7 +492,8 @@ int AliHLTTPCClusterFinderComponent::DoEvent( const AliHLTComponentEventData& ev Logging( kHLTLogFatal, "HLT::TPCClusterFinder::DoEvent", "Too much data", "Data written over allowed buffer. Amount written: %lu, allowed amount: %lu.", tSize, size ); - return -ENOSPC; + iResult=-ENOSPC; + break; } if(fUnsorted && fGetActivePads){ @@ -404,14 +509,287 @@ int AliHLTTPCClusterFinderComponent::DoEvent( const AliHLTComponentEventData& ev bdHW.fDataType = kAliHLTDataTypeHwAddr16; outputBlocks.push_back( bdHW ); + fBenchmark.AddOutput(bdHW.fSize); tSize+=nHWAdd*sizeof(AliHLTUInt16_t); } - fReader->Reset(); + + /* + { // compressed output for the CA tracker + + AliHLTUInt32_t dSize = 0; + + 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; + } + */ + + if(fDoMC){ + Int_t maxNumberOfClusterMCInfo = (Int_t)((size-tSize-sizeof(AliHLTTPCClusterMCData))/sizeof(AliHLTTPCClusterMCLabel)-1); + if( maxNumberOfClusterMCInfo>0 ){ + AliHLTTPCClusterMCData* outputMCInfo= (AliHLTTPCClusterMCData*)(outputPtr+tSize); + outputMCInfo->fCount = fClusterFinder->FillOutputMCInfo(outputMCInfo->fLabels, maxNumberOfClusterMCInfo); + + AliHLTComponentBlockData bdMCInfo; + FillBlockData( bdMCInfo ); + bdMCInfo.fOffset = tSize; + bdMCInfo.fSize = sizeof(AliHLTTPCClusterMCData)+outputMCInfo->fCount*sizeof(AliHLTTPCClusterMCLabel); + bdMCInfo.fSpecification = iter->fSpecification; + bdMCInfo.fDataType = AliHLTTPCDefinitions::fgkAliHLTDataTypeClusterMCInfo; + outputBlocks.push_back( bdMCInfo ); + fBenchmark.AddOutput(bdMCInfo.fSize); + tSize+=bdMCInfo.fSize; + } + } + + if (fPublishRawClusters) { + AliHLTTPCRawClusterData* outputRaw= (AliHLTTPCRawClusterData*)(outputPtr+tSize); + outputRaw->fCount = fClusterFinder->FillOutputRaw(outputRaw->fClusters, size-tSize); + + AliHLTComponentBlockData bdRawClusters; + FillBlockData( bdRawClusters ); + bdRawClusters.fOffset = tSize; + bdRawClusters.fSize = sizeof(AliHLTTPCRawClusterData)+outputRaw->fCount*sizeof(AliHLTTPCRawCluster); + bdRawClusters.fSpecification = iter->fSpecification; + bdRawClusters.fDataType = AliHLTTPCDefinitions::fgkRawClustersDataType; + outputBlocks.push_back( bdRawClusters ); + fBenchmark.AddOutput(bdRawClusters.fSize); + tSize+=bdRawClusters.fSize; + } } - - size = tSize; - return 0; + if (iResult>=0) + size = tSize; + + fBenchmark.Stop(0); + HLTInfo(fBenchmark.GetStatistics()); + return iResult; +} + +int AliHLTTPCClusterFinderComponent::ScanConfigurationArgument(int argc, const char** argv){ + + // see header file for class documentation + + if (argc<=0) return 0; + int i=0; + TString argument=argv[i]; + + 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 (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(fLastTimeBinSetUnsorted(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("-publish-raw")==0) { + fPublishRawClusters=kTRUE; + fClusterFinder->SetFillRawClusters(fPublishRawClusters); + 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; +} + +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:""); + AliCDBEntry *pEntry = AliCDBManager::Instance()->Get(path);//,GetRunNo()); + if (pEntry) { + TObjString* pString=dynamic_cast(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; + */ } int AliHLTTPCClusterFinderComponent::Configure(const char* arguments){ @@ -431,7 +809,6 @@ int AliHLTTPCClusterFinderComponent::Configure(const char* arguments){ if (argument.IsNull()) continue; - // -- deconvolute-time option if (argument.CompareTo("-deconvolute-time")==0){ HLTDebug("Switching on deconvolution in time direction."); @@ -444,13 +821,17 @@ int AliHLTTPCClusterFinderComponent::Configure(const char* arguments){ 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."); } + } else if (argument.CompareTo("-first-timebin")==0){ if ((bMissingParam=(++i>=pTokens->GetEntries()))) break; @@ -478,6 +859,16 @@ int AliHLTTPCClusterFinderComponent::Configure(const char* arguments){ 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'"); @@ -519,6 +910,9 @@ int AliHLTTPCClusterFinderComponent::Configure(const char* arguments){ 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; @@ -534,27 +928,53 @@ int AliHLTTPCClusterFinderComponent::Configure(const char* arguments){ return iResult; } -int AliHLTTPCClusterFinderComponent::Reconfigure(const char* cdbEntry, const char* chainId) -{ +void AliHLTTPCClusterFinderComponent::GetOCDBObjectDescription( TMap* const targetMap){ +// Get a list of OCDB object description needed for the particular component - int iResult=0; - // see header file for class documentation - 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:""); - AliCDBEntry *pEntry = AliCDBManager::Instance()->Get(path/*,GetRunNo()*/); - if (pEntry) { - TObjString* pString=dynamic_cast(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); - } + if (!targetMap) return; + + // OCDB entries for component arguments + switch(fModeSwitch){ + case kClusterFinderPacked: + // deprecated but kept for a short while to support porting to release + targetMap->Add(new TObjString("HLT/ConfigTPC/TPCClusterFinderPacked"), new TObjString("component arguments, empty at the moment")); + break; + case kClusterFinderUnpacked: + targetMap->Add(new TObjString("HLT/ConfigTPC/TPCClusterFinderUnpacked"), new TObjString("component arguments, empty at the moment")); + break; + case kClusterFinderDecoder: + // deprecated but kept for a short while to support porting to release + targetMap->Add(new TObjString("HLT/ConfigTPC/TPCClusterFinderDecoder"), new TObjString("component arguments, empty at the moment")); + break; + case kClusterFinder32Bit: + targetMap->Add(new TObjString("HLT/ConfigTPC/TPCClusterFinder32Bit"), new TObjString("component arguments, empty at the moment")); + break; } - return iResult; + + // 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")); }