-// @(#) $Id$
+// $Id$
//**************************************************************************
//* This file is property of and copyright by the ALICE HLT Project *
//* 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 "AliHLTTPCCalibPedestalComponent.h"
#include "AliHLTTPCCAInputDataCompressorComponent.h"
#include "AliHLTTPCCATrackerComponent.h"
+#include "AliHLTTPCCATrackerOutputConverter.h"
#include "AliHLTTPCTrackMCMarkerComponent.h"
#include "AliHLTTPCCAGlobalMergerComponent.h"
#include "AliHLTTPCdEdxComponent.h"
#include "AliHLTTPCTrackDumpComponent.h"
#include "AliHLTTPCHWCFDataReverterComponent.h"
#include "AliHLTTPCHWClusterTransformComponent.h"
+#include "AliHLTTPCCFComparisonComponent.h"
// #include "AliHLTTPCCalibSeedMakerComponent.h"
// #include "AliHLTTPCCalibTimeComponent.h"
// #include "AliHLTTPCCalibTimeGainComponent.h"
// #include "AliHLTTPCCalibrationComponent.h"
+#include "AliHLTTPCDataCheckerComponent.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)
{
// see header file for class documentation
// or
{
// 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<AliTPCParam*>(pEntry->GetObject()))) {
- } else {
- HLTWarning("can not load AliTPCParam from CDB entry %s", cdbEntry);
- }
- }
// This the tracking configuration for the full TPC
// - 216 clusterfinders (1 per partition)
int iMaxPart=5;
TString mergerInput;
TString sinkClusterInput;
+ TString dEdXInput;
for (int slice=iMinSlice; slice<=iMaxSlice; slice++) {
TString trackerInput;
for (int part=iMinPart; part<=iMaxPart; part++) {
// cluster finder components
cf.Form("TPC-CF_%02d_%d", slice, part);
- arg="";
- if (pTPCParam) {
- arg+=" -timebins "; arg+=pTPCParam->GetMaxTBin()+1;
- }
+ arg="-release-memory";
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());
+ 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
}
if (trackerInput.Length()>0) trackerInput+=" ";
trackerInput+=cf;
+ if (dEdXInput.Length()>0) dEdXInput+=" ";
+ dEdXInput+=cf;
if (sinkClusterInput.Length()>0) sinkClusterInput+=" ";
sinkClusterInput+=cf;
}
// GlobalMerger component
handler->CreateConfiguration("TPC-globalmerger","TPCCAGlobalMerger",mergerInput.Data(),"");
+ if (dEdXInput.Length()>0) dEdXInput+=" ";
+ dEdXInput+="TPC-globalmerger";
+
+ handler->CreateConfiguration("TPC-dEdx","TPCdEdx",dEdXInput.Data(),"");
+
// the esd converter configuration
TString converterInput="TPC-globalmerger";
if (!rawReader && runloader) {
// 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");
}
+
return 0;
}
// AliRoot simulation
//if (runloader->GetLoader("TPCLoader") != NULL)
//return "TPC-esd-converter TPC-clusters";
- return "TPC-clusters";
+
+ // 2010-10-26 TPC clusters not written to HLTOUT in order to make the simulation
+ // closer to the real data
+ //return "TPC-clusters";
}
return NULL;
}
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 AliHLTTPCTrackDumpComponent);
pHandler->AddComponent(new AliHLTTPCHWCFDataReverterComponent);
pHandler->AddComponent(new AliHLTTPCHWClusterTransformComponent);
+ pHandler->AddComponent(new AliHLTTPCCFComparisonComponent);
// pHandler->AddComponent(new AliHLTTPCCalibSeedMakerComponent);
// pHandler->AddComponent(new AliHLTTPCCalibTimeComponent);
// pHandler->AddComponent(new AliHLTTPCCalibTimeGainComponent);
// pHandler->AddComponent(new AliHLTTPCCalibrationComponent);
+ pHandler->AddComponent(new AliHLTTPCDataCheckerComponent);
return 0;
}
}
}
- // 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(kProprietary, dt, GetModuleId());
+ desc=AliHLTOUTHandlerDesc(kChain, dt, GetModuleId());
return 1;
}
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) {
delete fTracksegsDataHandler;
fTracksegsDataHandler=NULL;
}
+
+ if (pInstance==fClustersDataHandler) {
+ delete fClustersDataHandler;
+ fClustersDataHandler=NULL;
+ }
+
return 0;
}