//* provided "as is" without express or implied warranty. *
//**************************************************************************
-/** @file AliHLTTPCTrackHistoComponent.cxx
- @author Gaute Ovrebekk, Matthias Richter
- @date
- @brief The TPC conformal mapping tracker component.
-*/
-
-
-#if __GNUC__>= 3
-using namespace std;
-#endif
+/// @file AliHLTTPCTrackHistoComponent.cxx
+/// @author Gaute Ovrebekk, Matthias Richter, Kalliopi Kanaki
+/// @date
+/// @brief A histogram component with track and associated cluster properties
+///
#include "AliHLTTPCTrackHistoComponent.h"
#include "AliHLTTPCTransform.h"
#include "AliHLTTPCTrackletDataFormat.h"
#include "AliHLTTPCMemHandler.h"
#include "AliHLTTPCDefinitions.h"
+#include "AliHLTGlobalBarrelTrack.h"
+#include "AliHLTExternalTrackParam.h"
+#include "AliHLTDataTypes.h"
+
#include <TFile.h>
#include <TString.h>
+#include "TNtuple.h"
#include "TH1F.h"
+#include "TProfile.h"
#include "TObjString.h"
#include "TObjArray.h"
-//#include "AliHLTTPC.h"
-//#include <stdlib.h>
-//#include <cerrno>
-
-// this is a global object used for automatic component registration, do not use this
-AliHLTTPCTrackHistoComponent gAliHLTTPCTrackHistoComponent;
-
/** ROOT macro for the implementation of ROOT specific class methods */
ClassImp(AliHLTTPCTrackHistoComponent)
AliHLTTPCTrackHistoComponent::AliHLTTPCTrackHistoComponent()
-:
-fHistoNClustersOnTracks(NULL),
- fHistoAllClusters(NULL),
- fHistoUsedClusters(NULL),
- fHistoPT(NULL),
- fHistoResidual(NULL),
- fHistoTgl(NULL),
- fPlotAll(kFALSE),
- fPlotNClustersOnTracks(kFALSE),
- fPlotChargeClusters(kFALSE),
- fPlotChargeUsedClusters(kFALSE),
- fPlotPT(kFALSE),
- fPlotResidual(kFALSE),
- fPlotTgl(kFALSE),
- fClusters(),
- fTracks()
+ :
+ //, fReset(0)
+ fNEvents(0)
+ , fNtotTracks(0)
+ , fEvtMod(20)
+ , fBufferSize(5000)
+ , fdEdx(kFALSE)
+ , fMeanMultiplicity(NULL)
+ , fMultiplicity(NULL)
+ //, fdNdEta(NULL)
+ , fDeDxVsP(NULL)
+ , fClusters(NULL)
+ , fTracks(NULL)
+ //, fNClusterVsXY(NULL)
+ //, fChargeVsXY(NULL)
+ //, fClustersArray(NULL)
+ //, fNSpacePoints(NULL)
{
-
// see header file for class documentation
// or
// refer to README to build package
// or
// visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
-
}
-AliHLTTPCTrackHistoComponent::~AliHLTTPCTrackHistoComponent()
-{
- // see header file for class documentation
+const char* AliHLTTPCTrackHistoComponent::fgkOCDBEntry="HLT/ConfigTPC/TPCTrackHisto";
+
+AliHLTTPCTrackHistoComponent::~AliHLTTPCTrackHistoComponent(){
+// see header file for class documentation
}
// Public functions to implement AliHLTComponent's interface.
// These functions are required for the registration process
-const char* AliHLTTPCTrackHistoComponent::GetComponentID()
-{
- // see header file for class documentation
+const char* AliHLTTPCTrackHistoComponent::GetComponentID(){
+// see header file for class documentation
return "TPCTrackHisto";
}
-void AliHLTTPCTrackHistoComponent::GetInputDataTypes(AliHLTComponentDataTypeList& list)
-{
- // see header file for class documentation
+void AliHLTTPCTrackHistoComponent::GetInputDataTypes(AliHLTComponentDataTypeList& list){
+// see header file for class documentation
+
list.clear();
- list.push_back( AliHLTTPCDefinitions::fgkClustersDataType );
- list.push_back( AliHLTTPCDefinitions::fgkTrackSegmentsDataType );
- list.push_back( AliHLTTPCDefinitions::fgkTracksDataType );
+ list.push_back(AliHLTTPCDefinitions::fgkClustersDataType|kAliHLTDataOriginTPC);
+ list.push_back(kAliHLTDataTypeTrack|kAliHLTDataOriginTPC);
+ //list.push_back(kAliHLTDataTypeTObjArray|kAliHLTDataOriginTPC);
}
-AliHLTComponentDataType AliHLTTPCTrackHistoComponent::GetOutputDataType()
-{
- // see header file for class documentation
- return kAliHLTDataTypeHistogram;
+AliHLTComponentDataType AliHLTTPCTrackHistoComponent::GetOutputDataType(){
+// see header file for class documentation
+ return kAliHLTMultipleDataType;
+}
+int AliHLTTPCTrackHistoComponent::GetOutputDataTypes(AliHLTComponentDataTypeList& tgtList){
+// see header file for class documentation
+ tgtList.clear();
+ tgtList.push_back(kAliHLTDataTypeTNtuple|kAliHLTDataOriginTPC);
+ tgtList.push_back(kAliHLTDataTypeHistogram|kAliHLTDataOriginTPC);
+ return tgtList.size();
}
-void AliHLTTPCTrackHistoComponent::GetOutputDataSize( unsigned long& constBase, double& inputMultiplier )
-{
- // see header file for class documentation
- // XXX TODO: Find more realistic values.
- constBase = 0;
- inputMultiplier = 1;
+void AliHLTTPCTrackHistoComponent::GetOutputDataSize( unsigned long& constBase, double& inputMultiplier ){
+// see header file for class documentation
+
+ constBase = 5000;
+ inputMultiplier = 1;// XXX TODO: Find more realistic value
}
-AliHLTComponent* AliHLTTPCTrackHistoComponent::Spawn()
-{
- // see header file for class documentation
+AliHLTComponent* AliHLTTPCTrackHistoComponent::Spawn(){
+// see header file for class documentation
return new AliHLTTPCTrackHistoComponent;
}
-int AliHLTTPCTrackHistoComponent::DoInit( int argc, const char** argv )
-{
- fHistoNClustersOnTracks = new TH1F("fHistoNClustersOnTracks","Number of Clusters on Tracks",160,0,160);
- fHistoAllClusters = new TH1F("fHistoAllClusters","Charge of All Clusters",4000,0,4000);
- fHistoUsedClusters = new TH1F("fHistoUsedClusters","Charge of Clusters used on Tracks",4000,0,4000);
- fHistoPT = new TH1F("fHistoPT","pT of Tracks",100,0,10);
- fHistoResidual = new TH1F("fHistoResidual","Resuduals",360,0,360); //change. Testing
- fHistoTgl = new TH1F("fHistoTgl","Tgl of Tracks",900,0,90);
-
- fPlotAll=kFALSE;
- fPlotNClustersOnTracks=kFALSE;
- fPlotChargeClusters=kFALSE;
- fPlotChargeUsedClusters=kFALSE;
- fPlotPT=kFALSE;
- fPlotResidual=kFALSE;
- fPlotTgl=kFALSE;
-
+int AliHLTTPCTrackHistoComponent::DoInit( int argc, const char** argv ){
+// see header file for class documentation
+
+ fClusters = new TNtuple("fClusters", "fClusters", "charge:qmax:residualY:residualZ");
+ fTracks = new TNtuple("fTracks", "fTracks", "pt:eta:psi:nclusters");
+
+ fClusters->SetCircular(fBufferSize);
+ fTracks->SetCircular(fBufferSize);
+
+ fMultiplicity = new TH1F("fMultiplicity", "Track multiplicity per event", 1000, 0, 1000);
+ fMeanMultiplicity = new TH1F("fMeanMultiplicity", "Mean track multiplicity vs. #evt", 10000/fEvtMod, 0, 10000);
+ fDeDxVsP = new TProfile("fDeDxVsP", "E deposition per unit length vs. p",100, 0, 100);
+ fDeDxVsP->SetXTitle("p (GeV/c)");
+ //fdNdEta = new TH1F("fdNdEta", "dN/d#eta",100,-10,10);
+
+ // first configure the default
int iResult=0;
- TString configuration="";
- TString argument="";
- for (int i=0; i<argc && iResult>=0; i++) {
- argument=argv[i];
- if (!configuration.IsNull()) configuration+=" ";
- configuration+=argument;
- }
+ if (iResult>=0) iResult=ConfigureFromCDBTObjString(fgkOCDBEntry);
+
+ // configure from the command line parameters if specified
+ if (iResult>=0 && argc>0) iResult=ConfigureFromArgumentString(argc, argv);
- if (!configuration.IsNull()) {
- iResult=Configure(configuration.Data());
- }
- return iResult;
+ return iResult;
}
-int AliHLTTPCTrackHistoComponent::DoDeinit()
-{
- // see header file for class documentation
+int AliHLTTPCTrackHistoComponent::DoDeinit(){
+// see header file for class documentation
+
+ delete fClusters;
+ delete fTracks;
- delete fHistoNClustersOnTracks;
- delete fHistoAllClusters;
- delete fHistoUsedClusters;
- delete fHistoPT;
- delete fHistoResidual;
- delete fHistoTgl;
+ delete fMultiplicity;
+ delete fMeanMultiplicity;
+ delete fDeDxVsP;
+ //delete fdNdEta;
return 0;
}
-int AliHLTTPCTrackHistoComponent::DoEvent(const AliHLTComponentEventData& /*evtData*/, AliHLTComponentTriggerData& /*trigData*/)
-{
- const AliHLTComponentBlockData* iter = NULL;
+int AliHLTTPCTrackHistoComponent::Reconfigure(const char* cdbEntry, const char* /*chainId*/){
+// see header file for class documentation
+
+ // configure from the specified antry or the default one
+ const char* entry=cdbEntry;
+ if (!entry || entry[0]==0) {
+ entry=fgkOCDBEntry;
+ }
- if ( GetFirstInputBlock( kAliHLTDataTypeSOR ) || GetFirstInputBlock( kAliHLTDataTypeEOR ) )
- return 0;
+ return ConfigureFromCDBTObjString(entry);
+}
- Int_t TotalTrack = 0;
- //Reading Merged Tracks
- for ( iter = GetFirstInputBlock(AliHLTTPCDefinitions::fgkTracksDataType); iter != NULL; iter = GetNextInputBlock() ) {
- if(iter->fDataType!=AliHLTTPCDefinitions::fgkTracksDataType){continue;}
- ReadTracks(iter,TotalTrack);
- }
+int AliHLTTPCTrackHistoComponent::DoEvent(const AliHLTComponentEventData& /*evtData*/, AliHLTComponentTriggerData& /*trigData*/){
+// see header file for class documentation
- //Reading Tracks form slice
- for ( iter = GetFirstInputBlock(AliHLTTPCDefinitions::fgkTrackSegmentsDataType); iter != NULL; iter = GetNextInputBlock() ) {
- if(iter->fDataType!=AliHLTTPCDefinitions::fgkTrackSegmentsDataType){continue;}
- ReadTracks(iter,TotalTrack);
- }
+ if(GetFirstInputBlock(kAliHLTDataTypeSOR) || GetFirstInputBlock(kAliHLTDataTypeEOR)) return 0;
+
+ fNEvents++;
- int TotalSpacePoint = 0;
- int nClustersUsed=0;
+ const AliHLTComponentBlockData *iter = NULL;
+
+ for(int i=0; i<36; i++){
+ for(int j=0; j<6; j++){
+ fClustersArray[i][j] = NULL;
+ fNSpacePoints[i][j] = 0;
+ }
+ }
- for ( iter = GetFirstInputBlock(AliHLTTPCDefinitions::fgkClustersDataType); iter != NULL; iter = GetNextInputBlock() ) {
-
- if(iter->fDataType!=AliHLTTPCDefinitions::fgkClustersDataType){continue;}
-
- //AliHLTUInt8_t slice = AliHLTTPCDefinitions::GetMinSliceNr( *iter );
- //AliHLTUInt8_t patch = AliHLTTPCDefinitions::GetMinPatchNr( *iter );
-
- //HLTDebug ( "Input Data - TPC cluster - Slice/Patch: %d/%d.", slice, patch );
- const AliHLTTPCClusterData* clusterData = (const AliHLTTPCClusterData*) iter->fPtr;
- Int_t nSpacepoint = (Int_t) clusterData->fSpacePointCnt;
- TotalSpacePoint += nSpacepoint;
- //HLTInfo("TrackHisto found %d Spacepoints in slice %d patch %d", nSpacepoint, slice, patch);
- AliHLTTPCSpacePointData *clusters = (AliHLTTPCSpacePointData*) clusterData->fSpacePoints;
-
- for(int i=0;i<nSpacepoint;i++){
- UInt_t idCluster = clusters[i].fID;
- Int_t sliceCl = (idCluster>>25) & 0x7f;
- Int_t patchCl = (idCluster>>22) & 0x7;
- UInt_t pos = idCluster&0x3fffff;
- if(fPlotChargeClusters || fPlotAll){fHistoAllClusters->Fill(clusters[i].fCharge);}
- for(UInt_t id=0;id<fTrackClusterID[sliceCl][patchCl].size();id++){
- if(fTrackClusterID[sliceCl][patchCl][id]==pos){
- clusters[i].fUsed=kTRUE;
- nClustersUsed++;
- if(fPlotChargeUsedClusters || fPlotAll){fHistoUsedClusters->Fill(clusters[i].fCharge);}
- }
- }
- fClusters.push_back(clusters[i]);
- }
- }
-
- HLTInfo("TrackHisto found %d Spacepoints",TotalSpacePoint);
- HLTInfo("TrackHisto found %d Tracks",TotalTrack);
+
+ //----------------- loop over cluster blocks ---------------------//
- PushHisto();
+ Int_t totalSpacePoints = 0;
+
+ for(iter = GetFirstInputBlock(AliHLTTPCDefinitions::fgkClustersDataType); iter != NULL; iter = GetNextInputBlock()){
+
+ if(iter->fDataType!=AliHLTTPCDefinitions::fgkClustersDataType) continue;
+
+ AliHLTUInt8_t minSlice = AliHLTTPCDefinitions::GetMinSliceNr(*iter);
+ AliHLTUInt8_t minPartition = AliHLTTPCDefinitions::GetMinPatchNr(*iter);
+ //HLTDebug("Input Data - TPC cluster - slice/partition: %d/%d.", minSlice, minPartition);
+
+ const AliHLTTPCClusterData* clusterData = (const AliHLTTPCClusterData*)iter->fPtr;
+ Int_t nSpacepoint = (Int_t)clusterData->fSpacePointCnt;
+ totalSpacePoints += nSpacepoint;
+ HLTDebug("TrackHisto component found %d spacepoints in slice %d partition %d", nSpacepoint, minSlice, minPartition);
+
+ AliHLTTPCSpacePointData *clusters = (AliHLTTPCSpacePointData*)clusterData->fSpacePoints;
+
+ if(fClustersArray[minSlice][minPartition] != NULL){
+ delete(fClustersArray[minSlice][minPartition]); // ???????
+ fClustersArray[minSlice][minPartition] = NULL;
+ }
+
+ // fill the array with AliHLTTPCSpacePointData pointers
+ // it will be used in the track loop to access information
+ // for the used clusters only
+ fClustersArray[minSlice][minPartition] = clusters;
+ fNSpacePoints[minSlice][minPartition] = nSpacepoint;
+
+ if(nSpacepoint==0) fClustersArray[minSlice][minPartition] = NULL;
+
+ } // end of loop over cluster data blocks
+
+ HLTDebug("TrackHisto found %d spacepoints",totalSpacePoints);
+
+
+
+
+ //----------------- loop over merged tracks -------------------//
- fClusters.clear();
- fTracks.clear();
+ Int_t totalTracks = 0;
+
+ for(iter = GetFirstInputBlock(kAliHLTDataTypeTrack|kAliHLTDataOriginTPC); iter != NULL; iter = GetNextInputBlock()){
+ if(iter->fDataType != (kAliHLTDataTypeTrack|kAliHLTDataOriginTPC)) continue;
+ ReadTracks(iter,totalTracks);
+ }
+
+ HLTDebug("TrackHisto found %d tracks", totalTracks);
+
+ fMultiplicity->Fill(totalTracks);
+
+ fNtotTracks += totalTracks;
+
+ if(fNEvents%fEvtMod==0){
+ fMeanMultiplicity->Fill(fNEvents, Float_t(fNtotTracks)/(fEvtMod));
+ //HLTInfo("-------------- Event number: %d, total tracks accummulated %d", fNEvents, fNtotTracks);
+ fNtotTracks = 0;
+ }
+ PushHisto();
+
return 0;
}
- int AliHLTTPCTrackHistoComponent::Configure(const char* arguments)
- {
-
- int iResult=0;
- if (!arguments) return iResult;
-
- TString allArgs=arguments;
- TString argument;
-
- 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("-plot-All")==0) {
- HLTInfo("Ploting All Histograms for Tracks");
- fPlotAll = kTRUE;
- fPlotNClustersOnTracks=kTRUE;
- fPlotChargeClusters=kTRUE;
- fPlotChargeUsedClusters=kTRUE;
- fPlotPT=kTRUE;
- fPlotResidual=kTRUE;
- fPlotTgl=kTRUE;
- continue;
- }
- else if (argument.CompareTo("-plot-nClusters")==0) {
- HLTInfo("Ploting Number of clusters Used on Tracks");
- fPlotNClustersOnTracks = kTRUE;
- continue;
- }
- else if (argument.CompareTo("-plot-ChargeClusters")==0) {
- HLTInfo("Ploting Charge of All Clusters");
- fPlotChargeClusters = kTRUE;
- continue;
- }
- else if (argument.CompareTo("-plot-ChargeUsedClusters")==0) {
- HLTInfo("Ploting Charge of Clusters Used on Tracks");
- fPlotChargeUsedClusters = kTRUE;
- continue;
- }
- else if (argument.CompareTo("-plot-pT")==0) {
- HLTInfo("Ploting pT of Tracks");
- fPlotPT=kTRUE;
- continue;
- }
- else if (argument.CompareTo("-plot-Residuals")==0) {
- HLTInfo("Ploting Residuals");
- fPlotResidual=kTRUE;
- continue;
- }
- else if (argument.CompareTo("-plot-Tgl")==0) {
- HLTInfo("Ploting Tgl of Tracks");
- fPlotTgl=kTRUE;
- continue;
- }
- else {
- HLTError("unknown argument %s", argument.Data());
- iResult=-EINVAL;
- break;
- }
- }
- delete pTokens;
- }
-
- return iResult;
- }
-
void AliHLTTPCTrackHistoComponent::ReadTracks(const AliHLTComponentBlockData* iter,Int_t &tt){
+// see header file for class documentation
- //AliHLTUInt8_t slice = AliHLTTPCDefinitions::GetMinSliceNr( *iter );
- //AliHLTUInt8_t patch = AliHLTTPCDefinitions::GetMinPatchNr( *iter );
+ //AliHLTUInt8_t slice = AliHLTTPCDefinitions::GetMinSliceNr(*iter);
- //HLTDebug ( "Input Data - TPC cluster - Slice/Patch: %d/%d.", slice, patch );
- const AliHLTTPCTrackletData* trackData = (const AliHLTTPCTrackletData*) iter->fPtr;
- AliHLTUInt32_t nTracks = trackData->fTrackletCnt;
- tt += nTracks;
- //HLTInfo("TrackHisto found %d Tracks in slice %d patch %d", nTracks, slice, patch);
- AliHLTTPCTrackSegmentData *tracks = (AliHLTTPCTrackSegmentData*) trackData->fTracklets;
+ Int_t usedSpacePoints = 0;
- for(AliHLTUInt32_t i=0;i<nTracks;i++){
- fTracks.push_back(tracks[i]);
- UInt_t nHits = tracks->fNPoints;
- if(fPlotNClustersOnTracks || fPlotAll){fHistoNClustersOnTracks->Fill(nHits);}
- if(fPlotPT || fPlotAll){fHistoPT->Fill(tracks[i].fPt);}
- if(fPlotTgl || fPlotAll){fHistoTgl->Fill(tracks[i].fTgl);}
- const UInt_t *hitnum = tracks->fPointIDs;
- for(UInt_t h=0; h<nHits; h++){
- UInt_t idTrack = hitnum[h];
- Int_t sliceTrack = (idTrack>>25) & 0x7f;
- Int_t patchTrack = (idTrack>>22) & 0x7;
- UInt_t pos = idTrack&0x3fffff;
- fTrackClusterID[sliceTrack][patchTrack].push_back(pos);
- }
- UChar_t *tmpP = (UChar_t*)tracks;
- tmpP += sizeof(AliHLTTPCTrackSegmentData)+tracks->fNPoints*sizeof(UInt_t);
- tracks = (AliHLTTPCTrackSegmentData*)tmpP;
- }
+ vector<AliHLTGlobalBarrelTrack> tracksVector;
+ AliHLTGlobalBarrelTrack::ConvertTrackDataArray(reinterpret_cast<const AliHLTTracksData*>(iter->fPtr), iter->fSize, tracksVector);
+
+ tt = tracksVector.size();
+
+ for(vector<AliHLTGlobalBarrelTrack>::iterator element=tracksVector.begin(); element!=tracksVector.end(); element++){
+
+ Double_t trackLength = 0.;
+ if(fdEdx==kTRUE) trackLength = element->GetPathLengthTo( element->GetLastPointX(), 5.0);
+
+ UInt_t nHits = element->GetNumberOfPoints();
+ fTracks->Fill( 1./element->OneOverPt(), element->GetSnp(), element->GetTgl(), nHits );
+ //fdNdEta->Fill(element->GetSnp());
+
+ Double_t totCharge = 0;
+ const UInt_t *hitnum = element->GetPoints();
+ for(UInt_t i=0; i<element->GetNumberOfPoints(); i++){
+
+ UInt_t idTrack = hitnum[i];
+ Int_t sliceTrack = AliHLTTPCSpacePointData::GetSlice(idTrack);
+ Int_t patchTrack = AliHLTTPCSpacePointData::GetPatch(idTrack);
+ UInt_t pos = AliHLTTPCSpacePointData::GetNumber(idTrack);
+
+ if(sliceTrack<0 || sliceTrack>=36 || patchTrack<0 || patchTrack>5 ){
+ HLTError("Corrupted TPC cluster Id: slice %d, patch %d, cluster %d", sliceTrack, patchTrack, idTrack);
+ continue;
+ }
+
+ if( !fClustersArray[sliceTrack][patchTrack] ) continue;
+
+ if(fNSpacePoints[sliceTrack][patchTrack]<=pos ){
+ HLTError("Space point array out of boundaries!");
+ continue;
+ }
+
+ totCharge += (fClustersArray[sliceTrack][patchTrack])[pos].fCharge;
+
+ //Float_t xyz[3]; xyz[0] = xyz[1] = xyz[2] = 0.;
+
+ //xyz[0] = (fClustersArray[sliceTrack][patchTrack])[pos].fX;
+ //xyz[1] = (fClustersArray[sliceTrack][patchTrack])[pos].fY;
+ //xyz[2] = (fClustersArray[sliceTrack][patchTrack])[pos].fZ;
+
+ //AliHLTTPCTransform::Local2Global(xyz,slice);
+
+ //Double_t p[2] = { xyz[1], xyz[2] };
+ //Double_t cov[3] = { (fClustersArray[sliceTrack][patchTrack])[pos].fSigmaY2, 0., (fClustersArray[sliceTrack][patchTrack])[pos].fSigmaZ2};
+ //Double_t *res = element->GetResiduals(p,cov,kFALSE);
+
+ //HLTInfo("resy: %f, resz: %f", res[0], res[1]);
+
+ //if(!res) res[0] = res[1] = -1000.;
+ //else fClusters->Fill( (fClustersArray[sliceTrack][patchTrack])[pos].fCharge, (fClustersArray[sliceTrack][patchTrack])[pos].fQMax, res[0], res[1]);
+
+ fClusters->Fill( (fClustersArray[sliceTrack][patchTrack])[pos].fCharge, (fClustersArray[sliceTrack][patchTrack])[pos].fQMax, -1000., -1000.);
+
+ usedSpacePoints++;
+ }
+ if(fdEdx==kTRUE && trackLength > 0) fDeDxVsP->Fill(element->OneOverPt()*TMath::Sqrt(1.+element->GetTgl()*element->GetTgl()), totCharge/trackLength);
+ }
}
void AliHLTTPCTrackHistoComponent::PushHisto(){
+// see header file for class documentation
+
+ PushBack( (TObject*)fTracks, kAliHLTDataTypeTNtuple |kAliHLTDataOriginTPC, 0x0);
+ PushBack( (TObject*)fClusters, kAliHLTDataTypeTNtuple |kAliHLTDataOriginTPC, 0x0);
+ PushBack( (TObject*)fMultiplicity, kAliHLTDataTypeHistogram|kAliHLTDataOriginTPC, 0x0);
+ PushBack( (TObject*)fMeanMultiplicity, kAliHLTDataTypeHistogram|kAliHLTDataOriginTPC, 0x0);
+ PushBack( (TObject*)fDeDxVsP, kAliHLTDataTypeHistogram|kAliHLTDataOriginTPC, 0x0);
+ //PushBack( (TObject*)fdNdEta, kAliHLTDataTypeHistogram|kAliHLTDataOriginTPC, 0x0);
+}
- if(fPlotNClustersOnTracks || fPlotAll){
- AliHLTUInt32_t fSpecification = AliHLTTPCDefinitions::EncodeDataSpecification(0,35,0,5);
- PushBack( (TObject*) fHistoNClustersOnTracks,kAliHLTDataTypeHistogram, fSpecification);
- }
- if(fPlotChargeClusters || fPlotAll){
- AliHLTUInt32_t fSpecification = AliHLTTPCDefinitions::EncodeDataSpecification(0,35,0,5);
- PushBack( (TObject*) fHistoAllClusters,kAliHLTDataTypeHistogram, fSpecification);
- }
- if(fPlotChargeUsedClusters || fPlotAll){
- AliHLTUInt32_t fSpecification = AliHLTTPCDefinitions::EncodeDataSpecification(0,35,0,5);
- PushBack( (TObject*) fHistoUsedClusters,kAliHLTDataTypeHistogram, fSpecification);
- }
- if(fPlotPT || fPlotAll){
- AliHLTUInt32_t fSpecification = AliHLTTPCDefinitions::EncodeDataSpecification(0,35,0,5);
- PushBack( (TObject*) fHistoPT,kAliHLTDataTypeHistogram, fSpecification);
- }
- if(fPlotResidual || fPlotAll){
- for(unsigned int i=0;i<fTracks.size();i++){
- fHistoResidual->Fill(fTracks[i].fPsi); //Not rigth. Change here and x in Histo. Just for test.
- }
- AliHLTUInt32_t fSpecification = AliHLTTPCDefinitions::EncodeDataSpecification(0,35,0,5);
- PushBack( (TObject*) fHistoResidual,kAliHLTDataTypeHistogram, fSpecification);
- }
- if(fPlotTgl || fPlotAll){
- AliHLTUInt32_t fSpecification = AliHLTTPCDefinitions::EncodeDataSpecification(0,35,0,5);
- PushBack( (TObject*) fHistoTgl,kAliHLTDataTypeHistogram, fSpecification);
- }
+int AliHLTTPCTrackHistoComponent::ScanConfigurationArgument(int argc, const char** argv){
+// see header file for class documentation
+
+ if (argc<=0) return 0;
+ int i=0;
+ TString argument=argv[i];
+
+ // -event-modulo
+ if (argument.CompareTo("-event-modulo")==0) {
+ if (++i>=argc) return -EPROTO;
+ argument=argv[i];
+ fEvtMod=argument.Atoi();
+ return 2;
+ }
+
+ // -buffer-size
+ if (argument.CompareTo("-buffer-size")==0) {
+ if (++i>=argc) return -EPROTO;
+ argument=argv[i];
+ fBufferSize=argument.Atoi();
+ return 2;
+ }
- fHistoNClustersOnTracks->Reset();
- fHistoAllClusters->Reset();
- fHistoUsedClusters->Reset();
- fHistoPT->Reset();
- fHistoResidual->Reset();
- fHistoTgl->Reset();
+ // -dEdx
+ if (argument.CompareTo("-dEdx")==0) {
+ fdEdx=kTRUE;
+ return 1;
+ }
+ return -EINVAL;
+}
+
+void AliHLTTPCTrackHistoComponent::GetOCDBObjectDescription( TMap* const targetMap){
+// Get a list of OCDB object description needed for the particular component
+ if (!targetMap) return;
+ targetMap->Add(new TObjString("HLT/ConfigTPC/TPCTrackHisto"), new TObjString("component arguments for setting the size of the filled ntuples and the event modulo for the mean multiplicity distribution"));
}
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff