X-Git-Url: http://git.uio.no/git/?a=blobdiff_plain;f=HLT%2FTPCLib%2FAliHLTTPCAgent.cxx;h=a5b4314c67139f8f0a0032194f6205cc3f3686d0;hb=2893a43aed2382d07bb4268d490878c6e397a040;hp=02567d749a3547464c9e16bc838638317eb4c959;hpb=32e0c0224f90770d5f8ee25cca42062c18bc06b0;p=u%2Fmrichter%2FAliRoot.git diff --git a/HLT/TPCLib/AliHLTTPCAgent.cxx b/HLT/TPCLib/AliHLTTPCAgent.cxx index 02567d749a3..a5b4314c671 100644 --- a/HLT/TPCLib/AliHLTTPCAgent.cxx +++ b/HLT/TPCLib/AliHLTTPCAgent.cxx @@ -1,11 +1,10 @@ -// @(#) $Id$ +// $Id$ //************************************************************************** -//* This file is property of and copyright by the ALICE HLT Project * +//* This file is property of and copyright by the * //* ALICE Experiment at CERN, All rights reserved. * //* * //* Primary Authors: Matthias Richter * -//* 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 * @@ -16,74 +15,64 @@ //* provided "as is" without express or implied warranty. * //************************************************************************** -/** @file AliHLTTPCAgent.cxx - @author Matthias Richter - @date - @brief Agent of the libAliHLTTPC library -*/ +// @file AliHLTTPCAgent.cxx +// @author Matthias Richter +// @date +// @brief Agent of the libAliHLTTPC library +// @note #include "AliHLTTPCAgent.h" -#include "AliHLTConfiguration.h" #include "AliHLTTPCDefinitions.h" #include "AliHLTOUT.h" #include "AliHLTOUTHandlerChain.h" +#include "AliHLTMisc.h" #include "AliRunLoader.h" #include "AliCDBManager.h" #include "AliCDBEntry.h" #include "AliTPCParam.h" +#include "AliTPCRecoParam.h" +#include "TObject.h" /** global instance for agent registration */ AliHLTTPCAgent gAliHLTTPCAgent; // component headers -#include "AliHLTTPCRunStatisticsProducerComponent.h" -#include "AliHLTTPCEventStatisticsProducerComponent.h" -#include "AliHLTTPCCompModelInflaterComponent.h" -#include "AliHLTTPCCompModelDeflaterComponent.h" -#include "AliHLTTPCCompModelDeconverterComponent.h" -#include "AliHLTTPCCompModelConverterComponent.h" -#include "AliHLTTPCCompDumpComponent.h" -//#include "AliHLTTPCCalibCEComponent.h" -//#include "AliHLTTPCCalibPulserComponent.h" -//#include "AliHLTTPCCalibPedestalComponent.h" +#include "AliHLTTPCCAInputDataCompressorComponent.h" #include "AliHLTTPCCATrackerComponent.h" +#include "AliHLTTPCCATrackerOutputConverter.h" #include "AliHLTTPCTrackMCMarkerComponent.h" #include "AliHLTTPCCAGlobalMergerComponent.h" -#include "AliHLTTPCGlobalMergerComponent.h" -#include "AliHLTTPCSliceTrackerComponent.h" -#include "AliHLTTPCVertexFinderComponent.h" +#include "AliHLTTPCdEdxComponent.h" +#include "AliHLTTPCdEdxMonitoringComponent.h" #include "AliHLTTPCClusterFinderComponent.h" #include "AliHLTTPCRawDataUnpackerComponent.h" #include "AliHLTTPCDigitPublisherComponent.h" -#include "AliHLTTPCZeroSuppressionComponent.h" #include "AliHLTTPCDigitDumpComponent.h" #include "AliHLTTPCClusterDumpComponent.h" -#include "AliHLTTPCEsdWriterComponent.h" -#include "AliHLTTPCOfflineClustererComponent.h" -#include "AliHLTTPCOfflineTrackerComponent.h" -#include "AliHLTTPCOfflineTrackerCalibComponent.h" -#include "AliHLTTPCOfflineCalibrationComponent.h" // to be added to the calibration library agent #include "AliHLTTPCClusterHistoComponent.h" -#include "AliHLTTPCNoiseMapComponent.h" #include "AliHLTTPCHistogramHandlerComponent.h" -//#include "AliHLTTPCCalibTracksComponent.h" #include "AliHLTTPCTrackHistoComponent.h" #include "AliHLTTPCTrackDumpComponent.h" #include "AliHLTTPCHWCFDataReverterComponent.h" #include "AliHLTTPCHWClusterTransformComponent.h" -// #include "AliHLTTPCCalibSeedMakerComponent.h" -// #include "AliHLTTPCCalibTimeComponent.h" -// #include "AliHLTTPCCalibTimeGainComponent.h" -// #include "AliHLTTPCCalibrationComponent.h" +#include "AliHLTTPCCFComparisonComponent.h" +#include "AliHLTTPCDataCheckerComponent.h" +#include "AliHLTTPCHWCFEmulatorComponent.h" +#include "AliHLTTPCHWCFConsistencyControlComponent.h" +#include "AliHLTTPCDataCompressionComponent.h" +#include "AliHLTTPCDataCompressionMonitorComponent.h" +#include "AliHLTTPCDataCompressionFilterComponent.h" +#include "AliHLTTPCDataPublisherComponent.h" /** ROOT macro for the implementation of ROOT specific class methods */ ClassImp(AliHLTTPCAgent) AliHLTTPCAgent::AliHLTTPCAgent() - : - AliHLTModuleAgent("TPC"), - fRawDataHandler(NULL), - fTracksegsDataHandler(NULL) + : AliHLTModuleAgent("TPC") + , fRawDataHandler(NULL) + , fTracksegsDataHandler(NULL) + , fClustersDataHandler(NULL) + , fCompressionMonitorHandler(NULL) { // see header file for class documentation // or @@ -103,18 +92,9 @@ int AliHLTTPCAgent::CreateConfigurations(AliHLTConfigurationHandler* handler, { // see header file for class documentation if (handler) { - const char* cdbEntry="TPC/Calib/Parameters"; - AliCDBManager* pMan=AliCDBManager::Instance(); - AliTPCParam* pTPCParam=NULL; - if (pMan) { - AliCDBEntry *pEntry = pMan->Get(cdbEntry); - if (pEntry && - pEntry->GetObject() && - (pTPCParam=dynamic_cast(pEntry->GetObject()))) { - } else { - HLTWarning("can not load AliTPCParam from CDB entry %s", cdbEntry); - } - } + // AliSimulation: use the AliRawReaderPublisher if the raw reader is available + // AliReconstruction: indicated by runloader==NULL, run always on raw data + bool bPublishRaw=rawReader!=NULL || runloader==NULL; // This the tracking configuration for the full TPC // - 216 clusterfinders (1 per partition) @@ -126,69 +106,109 @@ int AliHLTTPCAgent::CreateConfigurations(AliHLTConfigurationHandler* handler, int iMaxSlice=35; int iMinPart=0; int iMaxPart=5; + TString arg; TString mergerInput; - TString sinkClusterInput; + TString sinkRawData; + TString sinkHWClusterInput; + TString dEdXInput; + TString hwclustOutput; + TString compressorInput; + TString trackerInput; + + + arg.Form("-publish-raw filtered"); + handler->CreateConfiguration("TPC-DP", "TPCDataPublisher", NULL , arg.Data()); + for (int slice=iMinSlice; slice<=iMaxSlice; slice++) { - TString trackerInput; for (int part=iMinPart; part<=iMaxPart; part++) { - TString arg, publisher, cf; + TString publisher; // digit publisher components publisher.Form("TPC-DP_%02d_%d", slice, part); - if (rawReader || !runloader) { + if (bPublishRaw) { // AliSimulation: use the AliRawReaderPublisher if the raw reader is available - // Alireconstruction: indicated by runloader==NULL, run always on raw data + // AliReconstruction: indicated by runloader==NULL, run always on raw data int ddlno=768; if (part>1) ddlno+=72+4*slice+(part-2); else ddlno+=2*slice+part; - arg.Form("-minid %d -datatype 'DDL_RAW ' 'TPC ' -dataspec 0x%02x%02x%02x%02x -silent", ddlno, slice, slice, part, part); - handler->CreateConfiguration(publisher.Data(), "AliRawReaderPublisher", NULL , arg.Data()); + arg.Form("-datatype 'DDL_RAW ' 'TPC ' -dataspec 0x%02x%02x%02x%02x", slice, slice, part, part); + handler->CreateConfiguration(publisher.Data(), "BlockFilter", "TPC-DP" , arg.Data()); + if (sinkRawData.Length()>0) sinkRawData+=" "; + sinkRawData+=publisher; } else { arg.Form("-slice %d -partition %d", slice, part); handler->CreateConfiguration(publisher.Data(), "TPCDigitPublisher", NULL , arg.Data()); } - // cluster finder components - cf.Form("TPC-CF_%02d_%d", slice, part); + // Hardware CF emulator + TString hwcfemu; + hwcfemu.Form("TPC-HWCFEmu_%02d_%d", slice, part); arg=""; - if (pTPCParam) { - arg+=" -timebins "; arg+=pTPCParam->GetMaxTBin()+1; - } - if (!rawReader && runloader) { - arg+=" -do-mc"; - handler->CreateConfiguration(cf.Data(), "TPCClusterFinderUnpacked", publisher.Data(), arg.Data()); - } else { -#ifndef HAVE_NOT_ALTRORAWSTREAMV3 - handler->CreateConfiguration(cf.Data(), "TPCClusterFinder32Bit", publisher.Data(), arg.Data()); -#else - // using the AltroDecoder if the official V3 decoder is not - // available in the offline code - handler->CreateConfiguration(cf.Data(), "TPCClusterFinderDecoder", publisher.Data(), arg.Data()); -#endif - } + if (!bPublishRaw) arg+=" -do-mc 1"; + handler->CreateConfiguration(hwcfemu.Data(), "TPCHWClusterFinderEmulator", publisher.Data(), arg.Data()); + if (hwclustOutput.Length()>0) hwclustOutput+=" "; + hwclustOutput+=hwcfemu; + + TString hwcf; + hwcf.Form("TPC-HWCF_%02d_%d", slice, part); + handler->CreateConfiguration(hwcf.Data(), "TPCHWClusterTransform",hwcfemu.Data(), "-publish-raw"); + if (trackerInput.Length()>0) trackerInput+=" "; - trackerInput+=cf; - if (sinkClusterInput.Length()>0) sinkClusterInput+=" "; - sinkClusterInput+=cf; + trackerInput+=hwcf; + if (dEdXInput.Length()>0) dEdXInput+=" "; + dEdXInput+=hwcf; + if (sinkHWClusterInput.Length()>0) sinkHWClusterInput+=" "; + sinkHWClusterInput+=hwcf; } - TString tracker; - // tracker finder components - tracker.Form("TPC-TR_%02d", slice); - handler->CreateConfiguration(tracker.Data(), "TPCCATracker", trackerInput.Data(), ""); + } - if (mergerInput.Length()>0) mergerInput+=" "; - mergerInput+=tracker; + // tracker finder component + // 2012-01-05 changing the configuration according to online setup + // the tracking strategy has been changed in the online system in Sep 2011 + // the tracker now processes all clusters, and several of this 'global' trackers + // run in parallel. The GlobalMerger is still in the chain as it produces the final + // fit. + TString tracker; + tracker.Form("TPC-TR"); + handler->CreateConfiguration(tracker.Data(), "TPCCATracker", trackerInput.Data(), "-GlobalTracking"); - } + if (mergerInput.Length()>0) mergerInput+=" "; + mergerInput+=tracker; // GlobalMerger component handler->CreateConfiguration("TPC-globalmerger","TPCCAGlobalMerger",mergerInput.Data(),""); + // dEdx component + if (dEdXInput.Length()>0) dEdXInput+=" "; + dEdXInput+="TPC-globalmerger"; + + handler->CreateConfiguration("TPC-dEdx","TPCdEdx",dEdXInput.Data(),""); + + // compression component + if (compressorInput.Length()>0) compressorInput+=" "; + compressorInput+=hwclustOutput; + + // special configuration to run the emulation automatically if the compressed clusters + // of a particular partition is missing. This configuration is announced for reconstruction + // of raw data if the HLT mode of the TPC reconstruction is enabled. Compression component + // always needs to run in mode 1. Even if the recorded data is mode 3 (optimized partition + // clusters), 2 (track model compression), or 4. The emulation can not be in mode 2 or 4, + // since the track model block can not be identified with a partition. Have to duplicate the + // configuration of the compression component + handler->CreateConfiguration("TPC-compression-emulation", "TPCDataCompressor", compressorInput.Data(), "-mode 1"); + + if (compressorInput.Length()>0) compressorInput+=" "; + compressorInput+="TPC-globalmerger"; + handler->CreateConfiguration("TPC-compression", "TPCDataCompressor", compressorInput.Data(), ""); + handler->CreateConfiguration("TPC-compression-huffman-trainer", "TPCDataCompressor", compressorInput.Data(),"-deflater-mode 3"); + handler->CreateConfiguration("TPC-compression-monitoring-component", "TPCDataCompressorMonitor", "TPC-compression TPC-hwcfdata","-pushback-period=30"); + handler->CreateConfiguration("TPC-compression-monitoring", "ROOTFileWriter", "TPC-compression-monitoring-component","-concatenate-events -overwrite -datafile HLT.TPCDataCompression-statistics.root"); + // the esd converter configuration TString converterInput="TPC-globalmerger"; - if (!rawReader && runloader) { + if (!bPublishRaw) { // propagate cluster info to the esd converter in order to fill the MC information - handler->CreateConfiguration("TPC-clustermc-info", "BlockFilter" , sinkClusterInput.Data(), "-datatype 'CLMCINFO' 'TPC '"); + handler->CreateConfiguration("TPC-clustermc-info", "BlockFilter" , sinkHWClusterInput.Data(), "-datatype 'CLMCINFO' 'TPC '"); handler->CreateConfiguration("TPC-mcTrackMarker","TPCTrackMCMarker","TPC-globalmerger TPC-clustermc-info","" ); converterInput+=" "; converterInput+="TPC-mcTrackMarker"; @@ -196,7 +216,27 @@ int AliHLTTPCAgent::CreateConfigurations(AliHLTConfigurationHandler* handler, handler->CreateConfiguration("TPC-esd-converter", "TPCEsdConverter" , converterInput.Data(), ""); // cluster dump collection - handler->CreateConfiguration("TPC-clusters", "BlockFilter" , sinkClusterInput.Data(), "-datatype 'CLUSTERS' 'TPC '"); + handler->CreateConfiguration("TPC-clusters", "BlockFilter" , sinkHWClusterInput.Data(), "-datatype 'CLUSTERS' 'TPC ' -datatype 'CLMCINFO' 'TPC '"); + handler->CreateConfiguration("TPC-raw-clusters", "BlockFilter" , sinkHWClusterInput.Data(), "-datatype 'CLUSTRAW' 'TPC ' -datatype 'CLMCINFO' 'TPC '"); + handler->CreateConfiguration("TPC-hwclusters", "BlockFilter" , sinkHWClusterInput.Data(), "-datatype 'CLUSTERS' 'TPC ' -datatype 'CLMCINFO' 'TPC '"); + handler->CreateConfiguration("TPC-raw-hwclusters", "BlockFilter" , sinkHWClusterInput.Data(), "-datatype 'CLUSTRAW' 'TPC ' -datatype 'CLMCINFO' 'TPC '"); + + // raw data + handler->CreateConfiguration("TPC-raw-data", "BlockFilter" , sinkRawData.Data(), ""); + + handler->CreateConfiguration("TPC-hwcfdata", "BlockFilter" , hwclustOutput.Data(), "-datatype 'HWCLUST1' 'TPC '"); + + ///////////////////////////////////////////////////////////////////////////////////// + // + // dumps on the ALTRO digit level + // + // selected channel dump + arg.Form("-datafile selected-channel.dump -specfmt=_0x%%08x -subdir -blcknofmt= -idfmt="); + handler->CreateConfiguration("TPC-selected-altro-digits", "TPCDigitDump", "RCU-channelselect", arg.Data()); + + // raw channel dump + arg.Form("-datafile channel.dump -specfmt=_0x%%08x -subdir -blcknofmt= -idfmt="); + handler->CreateConfiguration("TPC-raw-altro-digits", "TPCDigitDump", "TPC-raw-data", arg.Data()); ///////////////////////////////////////////////////////////////////////////////////// // @@ -222,7 +262,37 @@ int AliHLTTPCAgent::CreateConfigurations(AliHLTConfigurationHandler* handler, // the esd converter configuration handler->CreateConfiguration("TPC-hltout-tracks-esd-converter", "TPCEsdConverter", "TPC-hltout-tracks-publisher", ""); + + ///////////////////////////////////////////////////////////////////////////////////// + // + // a kChain HLTOUT configuration for processing of {'CLUSTERS':'TPC '} data blocks + // stores the blocks in file HLT.TPC.Clusters.root in HOMER format + + // publisher component + handler->CreateConfiguration("TPC-hltout-cluster-publisher", "AliHLTOUTPublisher" , NULL, ""); + + // the HLTOUT component collects the blocks and stores the file + handler->CreateConfiguration("TPC-hltout-cluster-dump", "HLTOUT", "TPC-hltout-cluster-publisher", "-digitfile HLT.TPC.Clusters.root -rawout=off -links 2"); + + ///////////////////////////////////////////////////////////////////////////////////// + // + // monitoring of compressed TPC data {CLUSTRAW:TPC }, {REMCLSCM,TPC }, {CLSTRKCM,TPC } + // + + // publisher component + handler->CreateConfiguration("TPC-hltout-compressionmonitor-publisher", "AliHLTOUTPublisher" , NULL, + "-datatype HWCLUST1 'TPC ' " + "-datatype CLUSTRAW 'TPC ' " + "-datatype REMCLSCM 'TPC ' " + "-datatype CLSTRKCM 'TPC ' " + "-datatype REMCLIDS 'TPC ' " + "-datatype CLIDSTRK 'TPC ' " + ); + + // the HLTOUT component collects the blocks and stores the file + handler->CreateConfiguration("TPC-hltout-compressionmonitor", "TPCDataCompressorMonitor", "TPC-hltout-compressionmonitor-publisher", "-histogram-file HLT.TPC-compression-statistics.root -publishing-mode off"); } + return 0; } @@ -232,11 +302,9 @@ const char* AliHLTTPCAgent::GetReconstructionChains(AliRawReader* /*rawReader*/, // see header file for class documentation if (runloader) { // reconstruction chains for AliRoot simulation - // Note: run loader is only available while running embedded into - // AliRoot simulation - //if (runloader->GetLoader("TPCLoader") != NULL) - //return "TPC-esd-converter TPC-clusters"; - return "TPC-clusters"; + return "TPC-compression"; + } else { + return "TPC-compression-emulation"; } return NULL; } @@ -256,50 +324,35 @@ int AliHLTTPCAgent::RegisterComponents(AliHLTComponentHandler* pHandler) const // see header file for class documentation if (!pHandler) return -EINVAL; - pHandler->AddComponent(new AliHLTTPCRunStatisticsProducerComponent); - pHandler->AddComponent(new AliHLTTPCEventStatisticsProducerComponent); -// pHandler->AddComponent(new AliHLTTPCCalibCEComponent); -// pHandler->AddComponent(new AliHLTTPCCalibPulserComponent); -// pHandler->AddComponent(new AliHLTTPCCalibPedestalComponent); - pHandler->AddComponent(new AliHLTTPCCompModelInflaterComponent); - pHandler->AddComponent(new AliHLTTPCCompModelDeflaterComponent); - pHandler->AddComponent(new AliHLTTPCCompModelDeconverterComponent); - pHandler->AddComponent(new AliHLTTPCCompModelConverterComponent); - pHandler->AddComponent(new AliHLTTPCCompDumpComponent); + pHandler->AddComponent(new AliHLTTPCCAInputDataCompressorComponent); pHandler->AddComponent(new AliHLTTPCCATrackerComponent); + pHandler->AddComponent(new AliHLTTPCCATrackerOutputConverter); pHandler->AddComponent(new AliHLTTPCCAGlobalMergerComponent); pHandler->AddComponent(new AliHLTTPCTrackMCMarkerComponent); - pHandler->AddComponent(new AliHLTTPCGlobalMergerComponent); - pHandler->AddComponent(new AliHLTTPCSliceTrackerComponent); - pHandler->AddComponent(new AliHLTTPCVertexFinderComponent); + pHandler->AddComponent(new AliHLTTPCdEdxComponent); + pHandler->AddComponent(new AliHLTTPCdEdxMonitoringComponent); pHandler->AddComponent(new AliHLTTPCClusterFinderComponent(AliHLTTPCClusterFinderComponent::kClusterFinderPacked)); pHandler->AddComponent(new AliHLTTPCClusterFinderComponent(AliHLTTPCClusterFinderComponent::kClusterFinderUnpacked)); pHandler->AddComponent(new AliHLTTPCClusterFinderComponent(AliHLTTPCClusterFinderComponent::kClusterFinderDecoder)); pHandler->AddComponent(new AliHLTTPCClusterFinderComponent(AliHLTTPCClusterFinderComponent::kClusterFinder32Bit)); pHandler->AddComponent(new AliHLTTPCRawDataUnpackerComponent); pHandler->AddComponent(new AliHLTTPCDigitPublisherComponent); - pHandler->AddComponent(new AliHLTTPCZeroSuppressionComponent); pHandler->AddComponent(new AliHLTTPCDigitDumpComponent); pHandler->AddComponent(new AliHLTTPCClusterDumpComponent); - pHandler->AddComponent(new AliHLTTPCEsdWriterComponent::AliWriter); - pHandler->AddComponent(new AliHLTTPCEsdWriterComponent::AliConverter); - pHandler->AddComponent(new AliHLTTPCOfflineClustererComponent); - pHandler->AddComponent(new AliHLTTPCOfflineTrackerComponent); - pHandler->AddComponent(new AliHLTTPCOfflineTrackerCalibComponent); - pHandler->AddComponent(new AliHLTTPCOfflineCalibrationComponent); pHandler->AddComponent(new AliHLTTPCClusterHistoComponent); - pHandler->AddComponent(new AliHLTTPCNoiseMapComponent); pHandler->AddComponent(new AliHLTTPCHistogramHandlerComponent); - //pHandler->AddComponent(new AliHLTTPCCalibTracksComponent); pHandler->AddComponent(new AliHLTTPCTrackHistoComponent); pHandler->AddComponent(new AliHLTTPCTrackDumpComponent); pHandler->AddComponent(new AliHLTTPCHWCFDataReverterComponent); pHandler->AddComponent(new AliHLTTPCHWClusterTransformComponent); -// pHandler->AddComponent(new AliHLTTPCCalibSeedMakerComponent); -// pHandler->AddComponent(new AliHLTTPCCalibTimeComponent); -// pHandler->AddComponent(new AliHLTTPCCalibTimeGainComponent); -// pHandler->AddComponent(new AliHLTTPCCalibrationComponent); - + pHandler->AddComponent(new AliHLTTPCCFComparisonComponent); + pHandler->AddComponent(new AliHLTTPCDataCheckerComponent); + pHandler->AddComponent(new AliHLTTPCHWCFEmulatorComponent); +// pHandler->AddComponent(new AliHLTTPCHWCFConsistencyControlComponent); //FIXME: Causes crash: https://savannah.cern.ch/bugs/?83677 + pHandler->AddComponent(new AliHLTTPCDataCompressionComponent); + pHandler->AddComponent(new AliHLTTPCDataCompressionMonitorComponent); + pHandler->AddComponent(new AliHLTTPCDataCompressionFilterComponent); + pHandler->AddComponent(new AliHLTTPCDataPublisherComponent); return 0; } @@ -326,8 +379,37 @@ int AliHLTTPCAgent::GetHandlerDescription(AliHLTComponentDataType dt, } } - // dump for {'CLUSTERS':'TPC '} currently not used any more + // dump for {'CLUSTERS':'TPC '} blocks stored in a 'digit' file if (dt==AliHLTTPCDefinitions::fgkClustersDataType) { + desc=AliHLTOUTHandlerDesc(kChain, dt, GetModuleId()); + return 1; + } + + // define handlers for all blocks related to compression, flag if the + // cluster id blocks are existing, this will be used to decide + // whether to create the handler or not + // {'CLUSTRAW':'TPC '} + // {'HWCLUST1':'TPC '} + // {'REMCLSCM':'TPC '} + // {'CLSTRKCM':'TPC '} + // {'REMCLIDS':'TPC '} + // {'CLIDSTRK':'TPC '} + if (dt==AliHLTTPCDefinitions::RawClustersDataType() || + dt==AliHLTTPCDefinitions::HWClustersDataType() || + dt==AliHLTTPCDefinitions::RemainingClustersCompressedDataType() || + dt==AliHLTTPCDefinitions::ClusterTracksCompressedDataType()) { + desc=AliHLTOUTHandlerDesc(kProprietary, dt, GetModuleId()); + return 1; + } + if (dt==AliHLTTPCDefinitions::RemainingClusterIdsDataType() || + dt==AliHLTTPCDefinitions::ClusterIdTracksDataType()) { + desc=AliHLTOUTHandlerDesc(kProprietary, dt, GetModuleId()); + const_cast(this)->SetBit(kHaveCompressedClusterIdDataBlock); + return 1; + } + + // {'CLMCINFO':'TPC '} + if (dt==AliHLTTPCDefinitions::fgkAliHLTDataTypeClusterMCInfo) { desc=AliHLTOUTHandlerDesc(kProprietary, dt, GetModuleId()); return 1; } @@ -360,6 +442,13 @@ AliHLTOUTHandler* AliHLTTPCAgent::GetOutputHandler(AliHLTComponentDataType dt, return fRawDataHandler; } + // dump for {'CLUSTERS':'TPC '}, stored in a file HLT.TPC.Clusters.root in HOMER format + if (dt==AliHLTTPCDefinitions::fgkClustersDataType) { + if (fClustersDataHandler==NULL) + fClustersDataHandler=new AliHLTOUTHandlerChain("chains=TPC-hltout-cluster-dump libHLTsim.so libAliHLTUtil.so"); + return fClustersDataHandler; + } + // afterburner for {'TRAKSEGS':'TPC '} blocks to be converted to ESD format // in a kChain HLTOUT handler if (dt==AliHLTTPCDefinitions::fgkTrackSegmentsDataType) { @@ -374,6 +463,24 @@ AliHLTOUTHandler* AliHLTTPCAgent::GetOutputHandler(AliHLTComponentDataType dt, return new AliHLTOUTHandlerChain("chains=TPC-hltout-tracks-esd-converter"); } + // monitoring of compressed data if cluster verification blocks exist + // {'REMCLIDS':'TPC '} + // {'CLIDSTRK':'TPC '} + // FIXME: needs to be commissioned + // if (dt==AliHLTTPCDefinitions::RawClustersDataType() || + // dt==AliHLTTPCDefinitions::HWClustersDataType() || + // dt==AliHLTTPCDefinitions::RemainingClustersCompressedDataType() || + // dt==AliHLTTPCDefinitions::ClusterTracksCompressedDataType() || + // dt==AliHLTTPCDefinitions::RemainingClusterIdsDataType() || + // dt==AliHLTTPCDefinitions::ClusterIdTracksDataType()) { + // const char* arg="chains=TPC-hltout-compressionmonitor"; + // if (!TestBit(kHaveCompressedClusterIdDataBlock)) + // arg="chains=TPC-hltout-compressionmonitorpublisher"; + // if (!fCompressionMonitorHandler) + // fCompressionMonitorHandler=new AliHLTOUTHandlerChain(arg); + // return fCompressionMonitorHandler; + // } + return NULL; } @@ -391,6 +498,17 @@ int AliHLTTPCAgent::DeleteOutputHandler(AliHLTOUTHandler* pInstance) delete fTracksegsDataHandler; fTracksegsDataHandler=NULL; } + + if (pInstance==fClustersDataHandler) { + delete fClustersDataHandler; + fClustersDataHandler=NULL; + } + + if (pInstance==fCompressionMonitorHandler) { + delete fCompressionMonitorHandler; + fCompressionMonitorHandler=NULL; + } + return 0; }