// $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> *
- * 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 <valgrind/callgrind.h>
+#else
+#define CALLGRIND_START_INSTRUMENTATION (void)0
+#define CALLGRIND_STOP_INSTRUMENTATION (void)0
+#endif
#include <cstdlib>
#include <cerrno>
#include <string>
-// this is a global object used for automatic component registration, do not use this
-AliHLTTRDClusterizerComponent gAliHLTTRDClusterizerComponent;
+using namespace std;
ClassImp(AliHLTTRDClusterizerComponent)
-
- AliHLTTRDClusterizerComponent::AliHLTTRDClusterizerComponent()
+
+AliHLTTRDClusterizerComponent::AliHLTTRDClusterizerComponent()
+: 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)
{
- fOutputPercentage = 100; // By default we copy to the output exactly what we got as input
-
+ // Default constructor
+
}
AliHLTTRDClusterizerComponent::~AliHLTTRDClusterizerComponent()
{
+ // Destructor
+ // Work is Done in DoDeInit()
}
+
const char* AliHLTTRDClusterizerComponent::GetComponentID()
{
+ // Return the component ID const char *
return "TRDClusterizer"; // The ID of this component
}
void AliHLTTRDClusterizerComponent::GetInputDataTypes( vector<AliHLTComponent_DataType>& list)
{
+ // Get the list of input data
list.clear(); // We do not have any requirements for our input data type(s).
- list.push_back( AliHLTTRDDefinitions::fgkDDLRawDataType );
+ list.push_back(kAliHLTDataTypeDDLRaw | kAliHLTDataOriginTRD);
}
-AliHLTComponent_DataType AliHLTTRDClusterizerComponent::GetOutputDataType()
+AliHLTComponentDataType AliHLTTRDClusterizerComponent::GetOutputDataType()
{
- return AliHLTTRDDefinitions::fgkClusterDataType;
+ // Get the output data type
+ return kAliHLTMultipleDataType;
}
-void AliHLTTRDClusterizerComponent::GetOutputDataSize( unsigned long& constBase, double& inputMultiplier )
+int AliHLTTRDClusterizerComponent::GetOutputDataTypes(AliHLTComponentDataTypeList& tgtList)
{
- constBase = 0;
- inputMultiplier = ((double)fOutputPercentage)/100.0;
+ // Get the output data type
+ tgtList.clear();
+ tgtList.push_back(AliHLTTRDDefinitions::fgkClusterDataType);
+ tgtList.push_back(AliHLTTRDDefinitions::fgkMCMtrackletDataType);
+ return tgtList.size();
}
+void AliHLTTRDClusterizerComponent::GetOutputDataSize( unsigned long& constBase, double& inputMultiplier )
+{
+ // Get the output data size
+ constBase = fOutputConst;
+ inputMultiplier = ((double)fOutputPercentage)*4/100.0;
+}
-// Spawn function, return new instance of this class
AliHLTComponent* AliHLTTRDClusterizerComponent::Spawn()
{
+ // Spawn function, return new instance of this class
return new AliHLTTRDClusterizerComponent;
};
int AliHLTTRDClusterizerComponent::DoInit( int argc, const char** argv )
{
// perform initialization. We check whether our relative output size is specified in the arguments.
- fOutputPercentage = 100;
- Int_t fRawDataVersion = 2;
- int i = 0;
- char* cpErr;
- while ( i < argc )
+ int iResult=0;
+
+ fReconstructor = new AliTRDReconstructor();
+ HLTDebug("TRDReconstructor at 0x%x", fReconstructor);
+
+ 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);
+ }
+
+ if(!fClusterizer){
+ HLTFatal("Clusterizer was not initialized!");
+ return -1;
+ }
+
+ if(iResult<0) return iResult;
+
+ fMemReader = new AliRawReaderMemory;
+ fClusterizer->SetReconstructor(fReconstructor);
+ fClusterizer->SetUseLabels(kFALSE);
+
+ if(fReconstructor->IsProcessingTracklets())
+ fOutputConst = fClusterizer->GetTrMemBlockSize();
+
+ return iResult;
+}
+
+int AliHLTTRDClusterizerComponent::DoDeinit()
+{
+ // Deinitialization of the component
+ delete fMemReader;
+ fMemReader = 0;
+ delete fClusterizer;
+ fClusterizer = 0;
+
+ //fReconstructor->SetClusters(0x0);
+ delete fReconstructor;
+ fReconstructor = 0x0;
+
+ if (fRecoParam)
{
- Logging( kHLTLogDebug, "HLT::TRDClusterizer::DoInit", "Arguments", "argv[%d] == %s", i, argv[i] );
- if ( !strcmp( argv[i], "output_percentage" ) )
+ HLTDebug("Deleting fRecoParam");
+ delete fRecoParam;
+ fRecoParam = 0;
+ }
+
+ return 0;
+}
+
+int AliHLTTRDClusterizerComponent::DoEvent( const AliHLTComponentEventData& evtData,
+ const AliHLTComponentBlockData* blocks,
+ AliHLTComponent_TriggerData& /*trigData*/,
+ AliHLTUInt8_t* outputPtr,
+ AliHLTUInt32_t& size,
+ vector<AliHLTComponent_BlockData>& outputBlocks )
+{
+ // Process an event
+
+#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
+ 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
+ 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)
{
- if ( i+1>=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;
+ 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;
}
-
- if ( strcmp( argv[i], "-cdb" ) == 0)
+ else
{
- 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;
- }
+ 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
+
+ // fMemReader->Reset();
+ fMemReader->SetMemory((UChar_t*) block.fPtr, block.fSize);
- if ( strcmp( argv[i], "-rawver" ) == 0)
+ AliHLTUInt32_t spec = block.fSpecification;
+
+ Int_t id = AliHLTTRDUtils::GetSM(spec) + 1024;
+
+ fMemReader->SetEquipmentID(id);
+
+ fClusterizer->SetMemBlock(outputPtr+offset);
+ Bool_t bclustered = fClusterizer->Raw2ClustersChamber(fMemReader);
+ if(bclustered)
{
- if ( i+1 >= argc )
+ HLTDebug("Clustered successfully");
+ }
+ else
+ {
+ HLTError("Clustering ERROR");
+ return -1;
+ }
+
+ 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 )
{
- Logging(kHLTLogError, "HLT::TRDClusterizer::DoInit", "Missing Argument", "Missing -rawver argument");
- return ENOTSUP;
+ HLTError("Too much data; Data written over allowed buffer. Amount written: %lu, allowed amount: %lu.",
+ totalSize, size );
+ return EMSGSIZE;
}
- fRawDataVersion = atoi( argv[i+1] );
- Logging( kHLTLogInfo, "HLT::TRDClusterizer::DoInit", "Raw Data", "Version is %d", fRawDataVersion );
- i += 2;
- continue;
- }
- Logging(kHLTLogError, "HLT::TRDClusterizer::DoInit", "Unknown Option", "Unknown option '%s'", argv[i] );
- return EINVAL;
- }
-
- cdb = AliCDBManager::Instance();
- if (!cdb)
- {
- Logging(kHLTLogError, "HLT::TRDCalibration::DoInit", "Could not get CDB instance", "cdb 0x%x", cdb);
- }
- else
- {
- cdb->SetRun(0); // THIS HAS TO BE RETRIEVED !!!
- cdb->SetDefaultStorage(fStrorageDBpath.c_str());
- Logging(kHLTLogDebug, "HLT::TRDCalibration::DoInit", "CDB instance", "cdb 0x%x", cdb);
+ // 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);
- rmem = new AliRawReaderMemory;
- clusterizer = new AliTRDclusterizerV1HLT("TRDCclusterizer", "TRDCclusterizer");
- clusterizer->SetRawDataVersion(fRawDataVersion);
- clusterizer->InitClusterTree();
+ size = totalSize;
+ HLTDebug("Event is done. size written to the output is %i", size);
return 0;
}
-int AliHLTTRDClusterizerComponent::DoDeinit()
+void AliHLTTRDClusterizerComponent::PrintObject(
+#ifdef __DEBUG
+ TClonesArray* inClustersArray
+#else
+ TClonesArray*
+#endif
+ )
{
- delete rmem;
- rmem = 0;
- delete clusterizer;
- clusterizer = 0;
- return 0;
+#ifdef __DEBUG
+ AliTRDcluster* cluster=0x0;
+
+ for (Int_t i=0; i < inClustersArray->GetEntriesFast(); i++){
+ cluster = dynamic_cast<AliTRDcluster*>(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
+}
- if (cdb)
- {
- Logging( kHLTLogDebug, "HLT::TRDCalibration::DoDeinit", "destroy", "cdb");
- cdb->Destroy();
- cdb = 0;
+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; i<pTokens->GetEntries() && 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;
+ }
}
+ delete pTokens;
+ }
+ if (bMissingParam) {
+ HLTError("missing parameter for argument %s", argument.Data());
+ iResult=-EINVAL;
+ }
+ if(iResult>=0){
+ iResult=SetParams();
+ }
+ return iResult;
}
-int AliHLTTRDClusterizerComponent::DoEvent( const AliHLTComponent_EventData& evtData, const AliHLTComponent_BlockData* blocks,
- AliHLTComponent_TriggerData& trigData, AliHLTUInt8_t* outputPtr,
- AliHLTUInt32_t& size, vector<AliHLTComponent_BlockData>& outputBlocks )
+int AliHLTTRDClusterizerComponent::SetParams()
{
- Logging( kHLTLogInfo, "HLT::TRDClusterizer::DoEvent", "Output percentage set", "Output percentage set to %lu %%", fOutputPercentage );
- Logging( kHLTLogInfo, "HLT::TRDClusterizer::DoEvent", "BLOCKS", "NofBlocks %lu", evtData.fBlockCnt );
- // Process an event
- unsigned long totalSize = 0;
- AliHLTUInt32_t fDblock_Specification = 0;
-
- // 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 )
+ 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
{
- Logging (kHLTLogError, "HLT::TRDClusterizer::DoEvent", "COMPARE FAILED", "type=%d is type=%d",
- blocks[i].fDataType, AliHLTTRDDefinitions::fgkDDLRawDataType);
- continue;
+ 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();
}
- fDblock_Specification = blocks[i].fSpecification;
- unsigned long blockSize = blocks[i].fSize;
- totalSize += blockSize;
}
+ if(fRecoParamType == 2){
+ HLTInfo("Cosmic Test params init.");
+ fRecoParam = AliTRDrecoParam::GetCosmicTestParam();
+ }
+ }
- void *memBufIn = calloc(totalSize, 1);
- AliHLTUInt8_t *pBuf = (AliHLTUInt8_t *)memBufIn;
- if (memBufIn == NULL)
+ if (!fRecoParam)
{
- Logging( kHLTLogError, "HLT::TRDClusterizer::DoEvent", "MEMORY", "Unable to allocate %lu bytes", totalSize);
- return -1;
+ HLTError("No reco params initialized. Sniffing big trouble!");
+ return -EINVAL;
}
- // Make the memory continuous
- unsigned long copied = 0;
- for ( unsigned long i = 0; i < evtData.fBlockCnt; i++ )
- {
- if ( blocks[i].fDataType != AliHLTTRDDefinitions::fgkDDLRawDataType )
- continue;
+ if(fTC){fRecoParam->SetTailCancelation(kTRUE); HLTDebug("Enableing Tail Cancelation"); }
+ else{fRecoParam->SetTailCancelation(kFALSE); HLTDebug("Disableing Tail Cancelation"); }
- void *pos = (void*)(pBuf + copied);
- void *copyret = memcpy(pos, blocks[i].fPtr, blocks[i].fSize);
- if (copyret < 0)
- {
- Logging( kHLTLogError, "HLT::TRDClusterizer::DoEvent", "MEMORY", "Unable to copy %lu bytes", blocks[i].fSize);
- return -1;
- }
- copied += blocks[i].fSize;
- }
+ 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;
+ }
- Logging( kHLTLogInfo, "HLT::TRDClusterizer::DoEvent", "COPY STATS", "total=%lu copied=%lu", totalSize, copied);
+ fRecoParam->SetStreamLevel(AliTRDrecoParam::kClusterizer, 0);
+ fReconstructor->SetRecoParam(fRecoParam);
- rmem->Reset();
- rmem->SetMemory((UChar_t*)memBufIn, totalSize);
- //rmem->Reset();
- Bool_t ihead = rmem->ReadHeader();
- if (ihead == kTRUE)
- {
- Logging( kHLTLogInfo, "HLT::TRDClusterizer::DoEvent", "HEADER", "Header read successfully");
- }
- else
- {
- Logging( kHLTLogError, "HLT::TRDClusterizer::DoEvent", "HEADER", "Header read ERROR");
- //return -1; -- not FATAL
- }
+ if(!fClusterizer){
+ fClusterizer = new AliHLTTRDClusterizer("TRDCclusterizer", "TRDCclusterizer");
+ HLTDebug("TRDClusterizer at 0x%x", fClusterizer);
+ }
- clusterizer->ResetTree();
- Bool_t ireadD = clusterizer->ReadDigits(rmem);
- if (ireadD == kTRUE)
- {
- Logging( kHLTLogInfo, "HLT::TRDClusterizer::DoEvent", "DIGITS", "Digits read successfully");
- }
- else
+ 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 = clusterizer->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 = clusterizer->WriteClustersToMemory(memBufOut, memBufOutSize);
- Int_t iNclusters = clusterizer->GetNclusters();
- Logging( kHLTLogInfo, "HLT::TRDClusterizer::DoEvent", "COUNT", "N of Clusters = %d", iNclusters);
+ return iResult;
+}
- // put the tree into output blocks of TObjArrays
- TTree *fcTree = clusterizer->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:"<none>");
+ AliCDBEntry *pEntry = AliCDBManager::Instance()->Get(path/*,GetRunNo()*/);
+ if (pEntry) {
+ TObjString* pString=dynamic_cast<TObjString*>(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"));
}