X-Git-Url: http://git.uio.no/git/?a=blobdiff_plain;f=HLT%2FTRD%2FAliHLTTRDClusterizerComponent.cxx;h=0b809f2b7975731844eb6fb8ee06a1d38ba97d3a;hb=cc3aa914cc3efc45547456f155643229e5948034;hp=a0f22af09e7a18b516840775fc6888cdf3c4a51f;hpb=3b021c259b745473a0415f450bf2196bb7cc8bdb;p=u%2Fmrichter%2FAliRoot.git diff --git a/HLT/TRD/AliHLTTRDClusterizerComponent.cxx b/HLT/TRD/AliHLTTRDClusterizerComponent.cxx index a0f22af09e7..0b809f2b797 100644 --- a/HLT/TRD/AliHLTTRDClusterizerComponent.cxx +++ b/HLT/TRD/AliHLTTRDClusterizerComponent.cxx @@ -1,66 +1,99 @@ // $Id$ -/************************************************************************** - * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. * - * * - * Authors: Matthias Richter * - * Timm Steinbeck * - * 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. * - **************************************************************************/ +//************************************************************************** +//* This file is property of and copyright by the ALICE HLT Project * +//* ALICE Experiment at CERN, All rights reserved. * +//* * +//* Primary Authors: * +//* 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 AliHLTTRDClusterizerComponent.cxx - @author Timm Steinbeck, Matthias Richter + @author Theodor Rascanu @date - @brief A TRDClusterizer processing component for the HLT. */ + @brief A TRDClusterizer processing component for the HLT. +*/ -#if __GNUC__ >= 3 -using namespace std; -#endif +// see header file for class documentation // +// or // +// refer to README to build package // +// or // +// visit http://web.ift.uib.no/~kjeks/doc/alice-hlt // + +#include "TTree.h" +#include "TFile.h" +#include "TBranch.h" #include "AliHLTTRDClusterizerComponent.h" #include "AliHLTTRDDefinitions.h" +#include "AliHLTTRDClusterizer.h" +#include "AliHLTTRDUtils.h" +#include "AliGeomManager.h" +#include "AliTRDReconstructor.h" #include "AliCDBManager.h" -#include "AliTRDclusterizerV1HLT.h" +#include "AliCDBStorage.h" +#include "AliCDBEntry.h" +#include "AliTRDrecoParam.h" +#include "AliTRDrawStream.h" +#include "AliTRDcluster.h" + #include "AliRawReaderMemory.h" -#include "TTree.h" -#include "TBranch.h" +#ifdef HAVE_VALGRIND_CALLGRIND_H +#include +#else +#define CALLGRIND_START_INSTRUMENTATION (void)0 +#define CALLGRIND_STOP_INSTRUMENTATION (void)0 +#endif #include #include #include -// this is a global object used for automatic component registration, do not use this -AliHLTTRDClusterizerComponent gAliHLTTRDClusterizerComponent; +using namespace std; -ClassImp(AliHLTTRDClusterizerComponent); +ClassImp(AliHLTTRDClusterizerComponent) AliHLTTRDClusterizerComponent::AliHLTTRDClusterizerComponent() - : AliHLTProcessor() - , fOutputPercentage(100) // By default we copy to the output exactly what we got as input - , fStrorageDBpath("local://$ALICE_ROOT") - , fClusterizer(NULL) - , fCDB(NULL) - , fMemReader(NULL) +: AliHLTProcessor(), + fOutputPercentage(100), + fOutputConst(0), + fClusterizer(NULL), + fRecoParam(NULL), + fMemReader(NULL), + fReconstructor(NULL), + fRecoParamType(-1), + fRecoDataType(-1), + fRawDataVersion(2), + fyPosMethod(1), + fgeometryFileName(""), + fProcessTracklets(kFALSE), + fHLTstreamer(kTRUE), + fTC(kFALSE), + fHLTflag(kTRUE), + fHighLevelOutput(kFALSE), + fEmulateHLTClusters(kFALSE) { // Default constructor + } AliHLTTRDClusterizerComponent::~AliHLTTRDClusterizerComponent() { // Destructor - ; + // Work is Done in DoDeInit() } + const char* AliHLTTRDClusterizerComponent::GetComponentID() { // Return the component ID const char * @@ -71,20 +104,30 @@ void AliHLTTRDClusterizerComponent::GetInputDataTypes( vector=argc ) - { - Logging(kHLTLogError, "HLT::TRDClusterizer::DoInit", "Missing Argument", "Missing output_percentage parameter"); - return ENOTSUP; - } - Logging( kHLTLogDebug, "HLT::TRDClusterizer::DoInit", "Arguments", "argv[%d+1] == %s", i, argv[i+1] ); - fOutputPercentage = strtoul( argv[i+1], &cpErr, 0 ); - if ( *cpErr ) - { - Logging(kHLTLogError, "HLT::TRDClusterizer::DoInit", "Wrong Argument", "Cannot convert output_percentage parameter '%s'", argv[i+1] ); - return EINVAL; - } - Logging( kHLTLogInfo, "HLT::TRDClusterizer::DoInit", "Output percentage set", "Output percentage set to %lu %%", fOutputPercentage ); - i += 2; - continue; - } + int iResult=0; + + fReconstructor = new AliTRDReconstructor(); + HLTDebug("TRDReconstructor at 0x%x", fReconstructor); + + TString configuration=""; + TString argument=""; + for (int i=0; i=0; i++) { + argument=argv[i]; + if (!configuration.IsNull()) configuration+=" "; + configuration+=argument; + } + + if (!configuration.IsNull()) { + iResult=Configure(configuration.Data()); + } else { + iResult=Reconfigure(NULL, NULL); + } + + if(!fClusterizer){ + HLTFatal("Clusterizer was not initialized!"); + return -1; + } + + if(iResult<0) return iResult; - if ( strcmp( argv[i], "-cdb" ) == 0) - { - if ( i+1 >= argc ) - { - Logging(kHLTLogError, "HLT::TRDClusterizer::DoInit", "Missing Argument", "Missing -cdb argument"); - return ENOTSUP; - } - fStrorageDBpath = argv[i+1]; - Logging( kHLTLogInfo, "HLT::TRDClusterizer::DoInit", "DB storage set", "DB storage is %s", fStrorageDBpath.c_str() ); - i += 2; - continue; - } - - if ( strcmp( argv[i], "-rawver" ) == 0) - { - if ( i+1 >= argc ) - { - Logging(kHLTLogError, "HLT::TRDClusterizer::DoInit", "Missing Argument", "Missing -rawver argument"); - return ENOTSUP; - } - fRawDataVersion = atoi( argv[i+1] ); - Logging( kHLTLogInfo, "HLT::TRDClusterizer::DoInit", "Raw Data", "Version is %d", fRawDataVersion ); - i += 2; - continue; - } + fMemReader = new AliRawReaderMemory; + fClusterizer->SetReconstructor(fReconstructor); + fClusterizer->SetUseLabels(kFALSE); - Logging(kHLTLogError, "HLT::TRDClusterizer::DoInit", "Unknown Option", "Unknown option '%s'", argv[i] ); - return EINVAL; - } + if(fReconstructor->IsProcessingTracklets()) + fOutputConst = fClusterizer->GetTrMemBlockSize(); - fCDB = AliCDBManager::Instance(); - if (!fCDB) - { - Logging(kHLTLogError, "HLT::TRDCalibration::DoInit", "Could not get CDB instance", "fCDB 0x%x", fCDB); - } - else - { - fCDB->SetRun(0); // THIS HAS TO BE RETRIEVED !!! - fCDB->SetDefaultStorage(fStrorageDBpath.c_str()); - Logging(kHLTLogDebug, "HLT::TRDCalibration::DoInit", "CDB instance", "fCDB 0x%x", fCDB); - } - - fMemReader = new AliRawReaderMemory; - fClusterizer = new AliTRDclusterizerV1HLT("TRDCclusterizer", "TRDCclusterizer"); - fClusterizer->SetRawDataVersion(fRawDataVersion); - fClusterizer->InitClusterTree(); - return 0; + return iResult; } int AliHLTTRDClusterizerComponent::DoDeinit() @@ -178,135 +182,537 @@ int AliHLTTRDClusterizerComponent::DoDeinit() fMemReader = 0; delete fClusterizer; fClusterizer = 0; - return 0; + + //fReconstructor->SetClusters(0x0); + delete fReconstructor; + fReconstructor = 0x0; - if (fCDB) + if (fRecoParam) { - Logging( kHLTLogDebug, "HLT::TRDCalibration::DoDeinit", "destroy", "fCDB"); - fCDB->Destroy(); - fCDB = 0; + HLTDebug("Deleting fRecoParam"); + delete fRecoParam; + fRecoParam = 0; } + + return 0; } -int AliHLTTRDClusterizerComponent::DoEvent( const AliHLTComponent_EventData& evtData, const AliHLTComponent_BlockData* blocks, - AliHLTComponent_TriggerData& trigData, AliHLTUInt8_t* outputPtr, - AliHLTUInt32_t& size, vector& outputBlocks ) +int AliHLTTRDClusterizerComponent::DoEvent( const AliHLTComponentEventData& evtData, + const AliHLTComponentBlockData* blocks, + AliHLTComponent_TriggerData& /*trigData*/, + AliHLTUInt8_t* outputPtr, + AliHLTUInt32_t& size, + vector& outputBlocks ) { // Process an event - Logging( kHLTLogInfo, "HLT::TRDClusterizer::DoEvent", "Output percentage set", "Output percentage set to %lu %%", fOutputPercentage ); - Logging( kHLTLogInfo, "HLT::TRDClusterizer::DoEvent", "BLOCKS", "NofBlocks %lu", evtData.fBlockCnt ); + +#ifdef HAVE_VALGRIND_CALLGRIND_H + if (evtData.fEventID == 10) + CALLGRIND_START_INSTRUMENTATION; + + if(GetFirstInputBlock(kAliHLTDataTypeEOR)) + CALLGRIND_STOP_INSTRUMENTATION; +#endif + + if(!IsDataEvent())return 0; + + HLTDebug( "NofBlocks %i", evtData.fBlockCnt ); // Process an event - unsigned long totalSize = 0; - AliHLTUInt32_t fDblock_Specification = 0; + AliHLTUInt32_t totalSize = 0, offset = 0; + + //implement a usage of the following + // AliHLTUInt32_t triggerDataStructSize = trigData.fStructSize; + // AliHLTUInt32_t triggerDataSize = trigData.fDataSize; + // void *triggerData = trigData.fData; + //HLTDebug( "Trigger data received. Struct size %d Data size %d Data location 0x%x", trigData.fStructSize, trigData.fDataSize, (UInt_t*)trigData.fData); // Loop over all input blocks in the event - for ( unsigned long i = 0; i < evtData.fBlockCnt; i++ ) - { - char tmp1[14], tmp2[14]; - DataType2Text( blocks[i].fDataType, tmp1 ); - DataType2Text( AliHLTTRDDefinitions::fgkDDLRawDataType, tmp2 ); - Logging( kHLTLogDebug, "HLT::TRDClusterizer::DoEvent", "Event received", - "Event 0x%08LX (%Lu) received datatype: %s - required datatype: %s", - evtData.fEventID, evtData.fEventID, tmp1, tmp2 ); - - if ( blocks[i].fDataType != AliHLTTRDDefinitions::fgkDDLRawDataType ) + AliHLTComponentDataType expectedDataType = (kAliHLTDataTypeDDLRaw | kAliHLTDataOriginTRD); + for ( UInt_t iBlock = 0; iBlock < evtData.fBlockCnt; iBlock++ ) + { + const AliHLTComponentBlockData &block = blocks[iBlock]; + // lets not use the internal TRD data types here : AliHLTTRDDefinitions::fgkDDLRawDataType + // which is depreciated - we use HLT global defs instead + // if ( block.fDataType != (kAliHLTDataTypeDDLRaw | kAliHLTDataOriginTRD) ) + AliHLTComponentDataType inputDataType = block.fDataType; + if ( inputDataType != expectedDataType) { - Logging (kHLTLogError, "HLT::TRDClusterizer::DoEvent", "COMPARE FAILED", "type=%d is type=%d", - blocks[i].fDataType, AliHLTTRDDefinitions::fgkDDLRawDataType); + HLTDebug( "Block # %i/%i; Event 0x%08LX (%Lu) Wrong received datatype: %s - required datatype: %s; Skipping", + iBlock, evtData.fBlockCnt, + evtData.fEventID, evtData.fEventID, + DataType2Text(inputDataType).c_str(), + DataType2Text(expectedDataType).c_str()); continue; } - fDblock_Specification = blocks[i].fSpecification; - unsigned long blockSize = blocks[i].fSize; - totalSize += blockSize; - } + else + { + HLTDebug("We get the right data type: Block # %i/%i; Event 0x%08LX (%Lu) Received datatype: %s; Block Size: %i", + iBlock, evtData.fBlockCnt, + evtData.fEventID, evtData.fEventID, + DataType2Text(inputDataType).c_str(), + block.fSize); + } + +#ifndef NDEBUG + unsigned long constBase; + double inputMultiplier; + GetOutputDataSize(constBase,inputMultiplier); + if(size<(constBase+block.fSize*inputMultiplier)){ + HLTWarning("Memory Block given might be too small: %i < %i; Event %Lu", size, constBase+block.fSize*inputMultiplier, evtData.fEventID); + } +#endif - void *memBufIn = calloc(totalSize, 1); - AliHLTUInt8_t *pBuf = (AliHLTUInt8_t *)memBufIn; - if (memBufIn == NULL) - { - Logging( kHLTLogError, "HLT::TRDClusterizer::DoEvent", "MEMORY", "Unable to allocate %lu bytes", totalSize); - return -1; - } + // fMemReader->Reset(); + fMemReader->SetMemory((UChar_t*) block.fPtr, block.fSize); - // Make the memory continuous - unsigned long copied = 0; - for ( unsigned long i = 0; i < evtData.fBlockCnt; i++ ) - { - if ( blocks[i].fDataType != AliHLTTRDDefinitions::fgkDDLRawDataType ) - continue; + AliHLTUInt32_t spec = block.fSpecification; + + Int_t id = AliHLTTRDUtils::GetSM(spec) + 1024; - void *pos = (void*)(pBuf + copied); - void *copyret = memcpy(pos, blocks[i].fPtr, blocks[i].fSize); - if (copyret < 0) + fMemReader->SetEquipmentID(id); + + fClusterizer->SetMemBlock(outputPtr+offset); + Bool_t bclustered = fClusterizer->Raw2ClustersChamber(fMemReader); + if(bclustered) + { + HLTDebug("Clustered successfully"); + } + else { - Logging( kHLTLogError, "HLT::TRDClusterizer::DoEvent", "MEMORY", "Unable to copy %lu bytes", blocks[i].fSize); + HLTError("Clustering ERROR"); return -1; } - copied += blocks[i].fSize; + + AliHLTUInt32_t addedSize; + if(fReconstructor->IsProcessingTracklets()){ + addedSize = fClusterizer->GetAddedTrSize(); + totalSize += fClusterizer->GetTrMemBlockSize(); //if IsProcessingTracklets() is enabled we always reserve a data block of size GetTrMemBlockSize() for the tracklets + if (addedSize > 0){ + // Using low-level interface + // with interface classes + if ( totalSize > size ) + { + HLTError("Too much data; Data written over allowed buffer. Amount written: %lu, allowed amount: %lu.", + totalSize, size ); + return EMSGSIZE; + } + + // Fill block + AliHLTComponentBlockData bd; + FillBlockData( bd ); + bd.fOffset = offset; + bd.fSize = addedSize; + bd.fSpecification = block.fSpecification; + bd.fDataType = AliHLTTRDDefinitions::fgkMCMtrackletDataType; + outputBlocks.push_back( bd ); + HLTDebug( "BD ptr 0x%x, offset %i, size %i, dataType %s, spec 0x%x ", bd.fPtr, bd.fOffset, bd.fSize, DataType2Text(bd.fDataType).c_str(), spec); + } + offset = totalSize; + } + + addedSize = fClusterizer->GetAddedClSize(); + if (addedSize > 0){ + + Int_t* nTimeBins = (Int_t*)(outputPtr+offset+fClusterizer->GetAddedClSize()); + *nTimeBins = fClusterizer->GetNTimeBins(); + addedSize += sizeof(*nTimeBins); + + totalSize += addedSize; + if ( totalSize > size ) + { + HLTError("Too much data; Data written over allowed buffer. Amount written: %lu, allowed amount: %lu.", + totalSize, size ); + return EMSGSIZE; + } + + // Fill block + AliHLTComponentBlockData bd; + FillBlockData( bd ); + bd.fOffset = offset; + bd.fSize = addedSize; + bd.fSpecification = block.fSpecification; + bd.fDataType = AliHLTTRDDefinitions::fgkClusterDataType; + outputBlocks.push_back( bd ); + HLTDebug( "BD ptr 0x%x, offset %i, size %i, dataType %s, spec 0x%x ", bd.fPtr, bd.fOffset, bd.fSize, DataType2Text(bd.fDataType).c_str(), spec); + offset = totalSize; + } + else{ + HLTDebug("Array of clusters is empty!"); + } } + //fReconstructor->SetClusters(0x0); - Logging( kHLTLogInfo, "HLT::TRDClusterizer::DoEvent", "COPY STATS", "total=%lu copied=%lu", totalSize, copied); + size = totalSize; + HLTDebug("Event is done. size written to the output is %i", size); + return 0; +} - fMemReader->Reset(); - fMemReader->SetMemory((UChar_t*)memBufIn, totalSize); - //fMemReader->Reset(); - Bool_t ihead = fMemReader->ReadHeader(); - if (ihead == kTRUE) - { - Logging( kHLTLogInfo, "HLT::TRDClusterizer::DoEvent", "HEADER", "Header read successfully"); +void AliHLTTRDClusterizerComponent::PrintObject( +#ifdef __DEBUG + TClonesArray* inClustersArray +#else + TClonesArray* +#endif + ) +{ +#ifdef __DEBUG + AliTRDcluster* cluster=0x0; + + for (Int_t i=0; i < inClustersArray->GetEntriesFast(); i++){ + cluster = dynamic_cast(inClustersArray->At(i)); + HLTDebug("cluster[%i]",i); + HLTDebug(" PadCol = %i; PadRow = %i; PadTime = %i", cluster->GetPadCol(), cluster->GetPadRow(), cluster->GetPadTime()); + HLTDebug(" Detector = %i, Amplitude = %f, Center = %f", cluster->GetDetector(), cluster->GetQ(), cluster->GetCenter()); + HLTDebug(" LocalTimeBin = %i; NPads = %i; maskedPosition: %s, status: %s", cluster->GetLocalTimeBin(), cluster->GetNPads(),cluster->GetPadMaskedPosition(),cluster->GetPadMaskedPosition()); + } +#endif +} + +int AliHLTTRDClusterizerComponent::Configure(const char* arguments){ + 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; iGetEntries() && iResult>=0; i++) { + argument=((TObjString*)pTokens->At(i))->GetString(); + if (argument.IsNull()) continue; + + if (argument.CompareTo("output_percentage")==0) { + if ((bMissingParam=(++i>=pTokens->GetEntries()))) break; + HLTInfo("Setting output percentage to: %s", ((TObjString*)pTokens->At(i))->GetString().Data()); + fOutputPercentage=((TObjString*)pTokens->At(i))->GetString().Atoi(); + continue; + } + else if (argument.CompareTo("-geometry")==0) { + if ((bMissingParam=(++i>=pTokens->GetEntries()))) break; + HLTInfo("Setting geometry to: %s", ((TObjString*)pTokens->At(i))->GetString().Data()); + fgeometryFileName=((TObjString*)pTokens->At(i))->GetString(); + continue; + } + else if (argument.CompareTo("-lowflux")==0) { + fRecoParamType = 0; + HLTInfo("Low flux reconstruction selected"); + continue; + } + else if (argument.CompareTo("-highflux")==0) { + fRecoParamType = 1; + HLTInfo("High flux reconstruction selected"); + continue; + } + else if (argument.CompareTo("-cosmics")==0) { + fRecoParamType = 2; + HLTInfo("Cosmics reconstruction selected"); + continue; + } + else if (argument.CompareTo("-simulation")==0) { + fRecoDataType = 0; + HLTInfo("Awaiting simulated data"); + continue; + } + else if (argument.CompareTo("-experiment")==0) { + fRecoDataType = 1; + HLTInfo("Awaiting real data"); + continue; + } + else if (argument.CompareTo("-processTracklets")==0) { + fProcessTracklets = kTRUE; + HLTInfo("Writing L1 tracklets to output"); + continue; + } + else if (argument.CompareTo("-noZS")==0) { + fOutputPercentage = 10; + HLTInfo("Awaiting non zero surpressed data"); + continue; + } + else if (argument.CompareTo("-HLTflag")==0) { + if ((bMissingParam=(++i>=pTokens->GetEntries()))) break; + TString toCompareTo=((TObjString*)pTokens->At(i))->GetString(); + if (toCompareTo.CompareTo("yes")==0){ + HLTInfo("Setting HLTflag to: %s", toCompareTo.Data()); + fHLTflag=kTRUE; + } + else if (toCompareTo.CompareTo("no")==0){ + HLTInfo("Setting HLTflag to: %s", toCompareTo.Data()); + fHLTflag=kFALSE; + } + else { + HLTError("unknown argument for HLTflag: %s", toCompareTo.Data()); + iResult=-EINVAL; + break; + } + continue; + } + else if (argument.CompareTo("-faststreamer")==0) { + fHLTstreamer = kTRUE; + HLTInfo("Useing fast raw streamer"); + continue; + } + else if (argument.CompareTo("-nofaststreamer")==0) { + fHLTstreamer = kFALSE; + HLTInfo("Don't use fast raw streamer"); + continue; + } + else if (argument.CompareTo("-tailcancellation")==0) { + fTC = kTRUE; + HLTInfo("Useing tailcancellation"); + continue; + } + else if (argument.CompareTo("-rawver")==0) { + if ((bMissingParam=(++i>=pTokens->GetEntries()))) break; + HLTInfo("Raw data version is: %s", ((TObjString*)pTokens->At(i))->GetString().Data()); + fRawDataVersion=((TObjString*)pTokens->At(i))->GetString().Atoi(); + continue; + } + else if (argument.CompareTo("-highLevelOutput")==0) { + if ((bMissingParam=(++i>=pTokens->GetEntries()))) break; + TString toCompareTo=((TObjString*)pTokens->At(i))->GetString(); + if (toCompareTo.CompareTo("yes")==0){ + HLTWarning("Setting highLevelOutput to: %s", toCompareTo.Data()); + fHighLevelOutput=kTRUE; + } + else if (toCompareTo.CompareTo("no")==0){ + HLTInfo("Setting highLevelOutput to: %s", toCompareTo.Data()); + fHighLevelOutput=kFALSE; + } + else { + HLTError("unknown argument for highLevelOutput: %s", toCompareTo.Data()); + iResult=-EINVAL; + break; + } + continue; + } + else if (argument.CompareTo("-emulateHLToutput")==0) { + if ((bMissingParam=(++i>=pTokens->GetEntries()))) break; + TString toCompareTo=((TObjString*)pTokens->At(i))->GetString(); + if (toCompareTo.CompareTo("yes")==0){ + HLTWarning("Setting emulateHLToutput to: %s", toCompareTo.Data()); + fEmulateHLTClusters=kTRUE; + } + else if (toCompareTo.CompareTo("no")==0){ + HLTInfo("Setting emulateHLToutput to: %s", toCompareTo.Data()); + fEmulateHLTClusters=kFALSE; + } + else { + HLTError("unknown argument for emulateHLToutput: %s", toCompareTo.Data()); + iResult=-EINVAL; + break; + } + continue; + } + else if (argument.CompareTo("-yPosMethod")==0) { + if ((bMissingParam=(++i>=pTokens->GetEntries()))) break; + TString toCompareTo=((TObjString*)pTokens->At(i))->GetString(); + if (toCompareTo.CompareTo("COG")==0){ + HLTInfo("Setting yPosMethod method to: %s", toCompareTo.Data()); + fyPosMethod=0; + } + else if (toCompareTo.CompareTo("LUT")==0){ + HLTInfo("Setting yPosMethod method to: %s", toCompareTo.Data()); + fyPosMethod=1; + } + else if (toCompareTo.CompareTo("Gauss")==0){ + HLTInfo("Setting yPosMethod method to: %s", toCompareTo.Data()); + fyPosMethod=2; + } + else { + HLTError("unknown argument for yPosMethod: %s", toCompareTo.Data()); + iResult=-EINVAL; + break; + } + continue; + } + + else { + HLTError("unknown argument: %s", argument.Data()); + iResult=-EINVAL; + break; + } } - else - { - Logging( kHLTLogError, "HLT::TRDClusterizer::DoEvent", "HEADER", "Header read ERROR"); - //return -1; -- not FATAL + delete pTokens; + } + if (bMissingParam) { + HLTError("missing parameter for argument %s", argument.Data()); + iResult=-EINVAL; + } + if(iResult>=0){ + iResult=SetParams(); + } + return iResult; +} + +int AliHLTTRDClusterizerComponent::SetParams() +{ + Int_t iResult=0; + if(!AliCDBManager::Instance()->IsDefaultStorageSet()){ + HLTError("DefaultStorage is not set in CDBManager"); + return -EINVAL; + } + if(AliCDBManager::Instance()->GetRun()<0){ + HLTError("Run Number is not set in CDBManager"); + return -EINVAL; + } + HLTInfo("CDB default storage: %s; RunNo: %i", (AliCDBManager::Instance()->GetDefaultStorage()->GetBaseFolder()).Data(), AliCDBManager::Instance()->GetRun()); + + if(!AliGeomManager::GetGeometry()){ + if(fgeometryFileName.CompareTo("")==0 || !TFile::Open(fgeometryFileName.Data())){ + HLTInfo("Loading standard geometry file"); + AliGeomManager::LoadGeometry(); + }else{ + HLTWarning("Loading NON-standard geometry file"); + AliGeomManager::LoadGeometry(fgeometryFileName.Data()); + } + if(!AliGeomManager::GetGeometry()){ + HLTError("Could not load geometry"); + return -EINVAL; + } + HLTInfo("Applying Alignment from CDB object"); + AliGeomManager::ApplyAlignObjsFromCDB("TRD"); + } + else{ + HLTInfo("Geometry Already Loaded!"); + } + + if(fReconstructor->GetRecoParam()){ + fRecoParam = new AliTRDrecoParam(*fReconstructor->GetRecoParam()); + HLTInfo("RecoParam already set!"); + }else{ + if(fRecoParamType == 0){ +#ifndef HAVE_NOT_ALITRD_RECOPARAM_r41621 + if(fHLTflag){ + HLTInfo("Low flux HLT params init."); + fRecoParam = AliTRDrecoParam::GetLowFluxHLTParam(); + }else +#endif + { + HLTInfo("Low flux params init."); + fRecoParam = AliTRDrecoParam::GetLowFluxParam(); + } } + if(fRecoParamType == 1){ +#ifndef HAVE_NOT_ALITRD_RECOPARAM_r41621 + if(fHLTflag){ + HLTInfo("High flux HLT params init."); + fRecoParam = AliTRDrecoParam::GetHighFluxHLTParam(); + }else +#endif + { + HLTInfo("High flux params init."); + fRecoParam = AliTRDrecoParam::GetHighFluxParam(); + } + } + if(fRecoParamType == 2){ + HLTInfo("Cosmic Test params init."); + fRecoParam = AliTRDrecoParam::GetCosmicTestParam(); + } + } - fClusterizer->ResetTree(); - Bool_t ireadD = fClusterizer->ReadDigits(fMemReader); - if (ireadD == kTRUE) + if (!fRecoParam) { - Logging( kHLTLogInfo, "HLT::TRDClusterizer::DoEvent", "DIGITS", "Digits read successfully"); + HLTError("No reco params initialized. Sniffing big trouble!"); + return -EINVAL; } - else + + if(fTC){fRecoParam->SetTailCancelation(kTRUE); HLTDebug("Enableing Tail Cancelation"); } + else{fRecoParam->SetTailCancelation(kFALSE); HLTDebug("Disableing Tail Cancelation"); } + + switch(fyPosMethod){ + case 0: fRecoParam->SetGAUS(kFALSE); fRecoParam->SetLUT(kFALSE); break; + case 1: fRecoParam->SetGAUS(kFALSE); fRecoParam->SetLUT(kTRUE); break; + case 2: fRecoParam->SetGAUS(kTRUE); fRecoParam->SetLUT(kFALSE); break; + } + + fRecoParam->SetStreamLevel(AliTRDrecoParam::kClusterizer, 0); + fReconstructor->SetRecoParam(fRecoParam); + + if(!fClusterizer){ + fClusterizer = new AliHLTTRDClusterizer("TRDCclusterizer", "TRDCclusterizer"); + HLTDebug("TRDClusterizer at 0x%x", fClusterizer); + } + + TString recoOptions="!cw"; + if(fHLTflag){ + recoOptions += ",hlt"; + + // we transfer clusters that do no contain the XYZ coodrinates (AliHLTTRDCluster), + // thus this coordinate transformation ist useless +#ifndef HAVE_NOT_ALITRD_CLUSTERIZER_r42837 + fClusterizer->SetSkipTransform(); +#endif + } + if(fProcessTracklets) recoOptions += ",tp"; + else recoOptions += ",!tp"; + + HLTDebug("Reconstructor options are: %s",recoOptions.Data()); + fReconstructor->SetOption(recoOptions.Data()); + + if (fRecoDataType < 0 || fRecoDataType > 1) { - Logging( kHLTLogError, "HLT::TRDClusterizer::DoEvent", "DIGITS", "Digits read ERROR"); - return -1; + HLTWarning("No data type selected. Use -simulation or -experiment flag. Defaulting to simulation."); + fRecoDataType = 0; } - Bool_t iclustered = fClusterizer->MakeClusters(); - if (iclustered == kTRUE) + if (fRecoDataType == 0) { - Logging( kHLTLogInfo, "HLT::TRDClusterizer::DoEvent", "CLUSTERS", "Clustered successfully"); + HLTDebug("Data type expected is SIMULATION!"); } - else + + if (fRecoDataType == 1) { - Logging( kHLTLogError, "HLT::TRDClusterizer::DoEvent", "CLUSTERS", "Clustering ERROR"); - return -1; + HLTDebug("Data type expected is EXPERIMENT!"); } - free(memBufIn); + fClusterizer->SetRawVersion(fRawDataVersion); - //UInt_t memBufOutSize = 0; - // void *memBufOut = fClusterizer->WriteClustersToMemory(memBufOut, memBufOutSize); - Int_t iNclusters = fClusterizer->GetNclusters(); - Logging( kHLTLogInfo, "HLT::TRDClusterizer::DoEvent", "COUNT", "N of Clusters = %d", iNclusters); + return iResult; +} - // put the tree into output blocks of TObjArrays - TTree *fcTree = fClusterizer->GetClusterTree(); - TList *lt = (TList*)fcTree->GetListOfBranches(); - TIter it(lt); - it.Reset(); - TBranch *tb = 0; - while ((tb = (TBranch*)it.Next()) != 0) - { - TObjArray *clusters = 0; - tb->SetAddress(&clusters); - for (Int_t icb = 0; icb < tb->GetEntries(); icb++) - { - tb->GetEntry(icb); - PushBack(clusters, AliHLTTRDDefinitions::fgkClusterDataType, fDblock_Specification); - } +int AliHLTTRDClusterizerComponent::Reconfigure(const char* cdbEntry, const char* chainId) +{ + // see header file for class documentation + + int iResult=0; + const char* path="HLT/ConfigTRD/ClusterizerComponent"; + const char* defaultNotify=""; + if (cdbEntry) { + path=cdbEntry; + defaultNotify=" (default)"; + } + if (path) { + HLTInfo("reconfigure from entry %s%s, chain id %s", path, defaultNotify,(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 string: \'%s\'", pString->GetString().Data()); + iResult=Configure(pString->GetString().Data()); + } else { + HLTError("configuration object \"%s\" has wrong type, required TObjString", path); + } + } else { + HLTError("cannot fetch object \"%s\" from CDB", path); } + } - return 0; + return iResult; +} + +void AliHLTTRDClusterizerComponent::GetOCDBObjectDescription(TMap* const targetMap){ + // Get a list of OCDB object description needed for the particular component + if (!targetMap) return; + targetMap->Add(new TObjString("HLT/ConfigTRD/ClusterizerComponent"), new TObjString("component arguments")); + targetMap->Add(new TObjString("TRD/Calib/ChamberGainFactor"), new TObjString("gain factor of chambers")); + targetMap->Add(new TObjString("TRD/Calib/ChamberT0"), new TObjString("T0 of chambers")); + targetMap->Add(new TObjString("TRD/Calib/ChamberVdrift"), new TObjString("drift velocity of chambers")); + targetMap->Add(new TObjString("TRD/Calib/DetNoise"), new TObjString("noise of chambers")); + targetMap->Add(new TObjString("TRD/Calib/LocalGainFactor"), new TObjString("per pad gain factor")); + targetMap->Add(new TObjString("TRD/Calib/LocalT0"), new TObjString("per pad T0")); + targetMap->Add(new TObjString("TRD/Calib/LocalVdrift"), new TObjString("per pad drift velocity")); + targetMap->Add(new TObjString("TRD/Calib/PadNoise"), new TObjString("per pad noise")); + targetMap->Add(new TObjString("TRD/Calib/PadStatus"), new TObjString("pad status")); + targetMap->Add(new TObjString("TRD/Calib/PRFWidth"), new TObjString("pad response function")); }