reverting r45444 to disentangle modules and make porting possible
[u/mrichter/AliRoot.git] / HLT / TPCLib / AliHLTTPCCFComparisonComponent.cxx
CommitLineData
cfe8311c 1// $Id$
2
3//**************************************************************************
4//* This file is property of and copyright by the ALICE HLT Project *
5//* ALICE Experiment at CERN, All rights reserved. *
6//* *
7//* Primary Authors: Kalliopi Kanaki <Kalliopi.Kanaki@ift.uib.no> *
8//* for The ALICE HLT Project. *
9//* *
10//* Permission to use, copy, modify and distribute this software and its *
11//* documentation strictly for non-commercial purposes is hereby granted *
12//* without fee, provided that the above copyright notice appears in all *
13//* copies and that both the copyright notice and this permission notice *
14//* appear in the supporting documentation. The authors make no claims *
15//* about the suitability of this software for any purpose. It is *
16//* provided "as is" without express or implied warranty. *
17//**************************************************************************
18
19/** @file AliHLTTPCCFComparisonComponent.cxx
20 @author Kalliopi Kanaki
21 @date
22 @brief A comparison component for FCF and SCF properties
23*/
24
25#if __GNUC__>= 3
26using namespace std;
27#endif
28
29#include "AliHLTTPCCFComparisonComponent.h"
30#include "AliHLTTPCTransform.h"
31#include "AliHLTTPCClusterDataFormat.h"
32#include "AliHLTTPCTrackletDataFormat.h"
33#include "AliHLTTPCMemHandler.h"
34#include "AliHLTTPCDefinitions.h"
35#include "AliHLTGlobalBarrelTrack.h"
36#include "AliHLTExternalTrackParam.h"
37#include "AliHLTDataTypes.h"
38
39#include <TFile.h>
40#include <TString.h>
41#include "TNtuple.h"
42#include "TH1F.h"
43#include "TObjString.h"
44#include "TObjArray.h"
45
46#include "AliHLTTPCTrack.h"
47
48
49/** ROOT macro for the implementation of ROOT specific class methods */
50ClassImp(AliHLTTPCCFComparisonComponent)
51
52AliHLTTPCCFComparisonComponent::AliHLTTPCCFComparisonComponent()
53 :
54 fEvtMod(20)
55 , fBufferSize(5000)
56 , fMultiplicity(NULL)
57 , fClusters(NULL)
58 , fTracks(NULL)
59{
60 // see header file for class documentation
61 // or
62 // refer to README to build package
63 // or
64 // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
65 for(int i=0; i<36; i++){
66 for(int j=0; j<6; j++){
67 fSCFClustersArray[i][j] = NULL;
68 fSCFNSpacePoints[i][j] = 0;
69 fFCFClustersArray[i][j] = NULL;
70 fFCFNSpacePoints[i][j] = 0;
71 }
72 }
73}
74
75const char* AliHLTTPCCFComparisonComponent::fgkOCDBEntry="HLT/ConfigTPC/TPCCFComparison";
76
77AliHLTTPCCFComparisonComponent::~AliHLTTPCCFComparisonComponent(){
78// see header file for class documentation
79 for(int i=0; i<36; i++){
80 for(int j=0; j<6; j++){
81 delete[] fSCFClustersArray[i][j];
82 fSCFClustersArray[i][j] = NULL;
83 delete[] fSCFClustersArray[i][j];
84 fSCFClustersArray[i][j] = NULL;
85 }
86 }
87}
88
89// Public functions to implement AliHLTComponent's interface.
90// These functions are required for the registration process
91
92const char* AliHLTTPCCFComparisonComponent::GetComponentID(){
93// see header file for class documentation
94
95 return "TPCCFComparison";
96}
97
98void AliHLTTPCCFComparisonComponent::GetInputDataTypes(AliHLTComponentDataTypeList& list){
99// see header file for class documentation
100
101 list.clear();
102 list.push_back(AliHLTTPCDefinitions::fgkClustersDataType|kAliHLTDataOriginTPC);
103 list.push_back(AliHLTTPCDefinitions::fgkAlterClustersDataType|kAliHLTDataOriginTPC);
104 list.push_back(kAliHLTDataTypeTrack|kAliHLTDataOriginTPC);
105}
106
107AliHLTComponentDataType AliHLTTPCCFComparisonComponent::GetOutputDataType(){
108// see header file for class documentation
109 return kAliHLTMultipleDataType;
110}
111
112int AliHLTTPCCFComparisonComponent::GetOutputDataTypes(AliHLTComponentDataTypeList& tgtList){
113// see header file for class documentation
114 tgtList.clear();
115 tgtList.push_back(kAliHLTDataTypeTNtuple|kAliHLTDataOriginTPC);
116 tgtList.push_back(kAliHLTDataTypeHistogram|kAliHLTDataOriginTPC);
117 return tgtList.size();
118}
119
120void AliHLTTPCCFComparisonComponent::GetOutputDataSize( unsigned long& constBase, double& inputMultiplier ){
121// see header file for class documentation
122
123 constBase = 5000;
124 inputMultiplier = 1;// XXX TODO: Find more realistic value
125}
126
127AliHLTComponent* AliHLTTPCCFComparisonComponent::Spawn(){
128// see header file for class documentation
129 return new AliHLTTPCCFComparisonComponent;
130}
131
132int AliHLTTPCCFComparisonComponent::DoInit( int argc, const char** argv ){
133// see header file for class documentation
134
135 fClusters = new TNtuple("fClusters", "fClusters", "charge:qmax:residualY:residualZ");
136 fTracks = new TNtuple("fTracks", "fTracks", "pt:eta:psi:nclusters");
137
138 fClusters->SetCircular(fBufferSize);
139 fTracks->SetCircular(fBufferSize);
140
141 fMultiplicity = new TH1F("fMultiplicity","Track multiplicity per event", 1000, 0, 1000);
142
143
144 // first configure the default
145 int iResult=0;
146 if (iResult>=0) iResult=ConfigureFromCDBTObjString(fgkOCDBEntry);
147
148 // configure from the command line parameters if specified
149 if (iResult>=0 && argc>0) iResult=ConfigureFromArgumentString(argc, argv);
150
151 return iResult;
152}
153
154int AliHLTTPCCFComparisonComponent::DoDeinit(){
155// see header file for class documentation
156
157 delete fClusters;
158 delete fTracks;
159 delete fMultiplicity;
160
161 return 0;
162}
163
164int AliHLTTPCCFComparisonComponent::Reconfigure(const char* cdbEntry, const char* /*chainId*/){
165// see header file for class documentation
166
167 // configure from the specified antry or the default one
168 const char* entry=cdbEntry;
169 if (!entry || entry[0]==0) {
170 entry=fgkOCDBEntry;
171 }
172 return ConfigureFromCDBTObjString(entry);
173}
174
175
176int AliHLTTPCCFComparisonComponent::DoEvent(const AliHLTComponentEventData& /*evtData*/, AliHLTComponentTriggerData& /*trigData*/){
177// see header file for class documentation
178
179 if(GetFirstInputBlock(kAliHLTDataTypeSOR) || GetFirstInputBlock(kAliHLTDataTypeEOR)) return 0;
180
181 const AliHLTComponentBlockData *iter = NULL;
182
183 for(int i=0; i<36; i++){
184 for(int j=0; j<6; j++){
185 fSCFClustersArray[i][j] = NULL;
186 fSCFNSpacePoints[i][j] = 0;
187 fFCFClustersArray[i][j] = NULL;
188 fFCFNSpacePoints[i][j] = 0;
189 }
190 }
191
192
193 //----------------- loop over SCF output blocks ---------------------//
194
195 //Int_t totalSpacePoints = 0;
196
197 for(iter = GetFirstInputBlock(AliHLTTPCDefinitions::fgkClustersDataType); iter != NULL; iter = GetNextInputBlock()){
198
199 if(iter->fDataType!=AliHLTTPCDefinitions::fgkClustersDataType) continue;
200
201 AliHLTUInt8_t minSlice = AliHLTTPCDefinitions::GetMinSliceNr(*iter);
202 AliHLTUInt8_t minPartition = AliHLTTPCDefinitions::GetMinPatchNr(*iter);
203 //HLTDebug("Input Data - TPC cluster - slice/partition: %d/%d.", minSlice, minPartition);
204
205 const AliHLTTPCClusterData* clusterData = (const AliHLTTPCClusterData*)iter->fPtr;
206 Int_t nSpacepoint = (Int_t)clusterData->fSpacePointCnt;
207 //totalSpacePoints += nSpacepoint;
208 HLTDebug("TPCCFComparison component found %d SCF spacepoints in slice %d partition %d", nSpacepoint, minSlice, minPartition);
209
210 AliHLTTPCSpacePointData *clusters = (AliHLTTPCSpacePointData*)clusterData->fSpacePoints;
211
212 if(fSCFClustersArray[minSlice][minPartition] != NULL){
213 delete(fSCFClustersArray[minSlice][minPartition]);
214 fSCFClustersArray[minSlice][minPartition] = NULL;
215 }
216
217 fSCFClustersArray[minSlice][minPartition] = clusters;
218 fSCFNSpacePoints[minSlice][minPartition] = nSpacepoint;
219
220 HLTInfo("SCF cluster loop charge %d, slice %d partition %d\n", (UInt_t)clusters->fCharge, minSlice, minPartition);
221
222 // Here are all the cluster data you can use:
223
224 //Float_t fX; // X coordinate in local coordinates
225 //Float_t fY; // Y coordinate in local coordinates
226 //Float_t fZ; // Z coordinate in local coordinates
227 //UInt_t fID; // contains slice patch and number
228 //UChar_t fPadRow; // Pad row number
229 //Float_t fSigmaY2; // error (former width) of the clusters
230 //Float_t fSigmaZ2; // error (former width) of the clusters
231 //UInt_t fCharge; // total charge of cluster
232 //UInt_t fQMax; // QMax of cluster
233
234
235 if(nSpacepoint==0) fSCFClustersArray[minSlice][minPartition] = NULL;
236
237 } // end of loop over cluster data blocks
238
239 //HLTDebug("TPCCFComparison found %d spacepoints",totalSpacePoints);
240
241
242 //----------------- loop over FCF output blocks ---------------------//
243
244
245 for(iter = GetFirstInputBlock(AliHLTTPCDefinitions::fgkAlterClustersDataType); iter != NULL; iter = GetNextInputBlock()){
246
247 if(iter->fDataType!=AliHLTTPCDefinitions::fgkAlterClustersDataType) continue;
248
249 AliHLTUInt8_t minSlice = AliHLTTPCDefinitions::GetMinSliceNr(*iter);
250 AliHLTUInt8_t minPartition = AliHLTTPCDefinitions::GetMinPatchNr(*iter);
251 //HLTDebug("Input Data - TPC cluster - slice/partition: %d/%d.", minSlice, minPartition);
252
253 const AliHLTTPCClusterData* clusterData = (const AliHLTTPCClusterData*)iter->fPtr;
254 Int_t nSpacepoint = (Int_t)clusterData->fSpacePointCnt;
255 //totalSpacePoints += nSpacepoint;
256 HLTDebug("TPCCFComparison component found %d FCF spacepoints in slice %d partition %d", nSpacepoint, minSlice, minPartition);
257
258 AliHLTTPCSpacePointData *clusters = (AliHLTTPCSpacePointData*)clusterData->fSpacePoints;
259
260 if(fFCFClustersArray[minSlice][minPartition] != NULL){
261 delete(fFCFClustersArray[minSlice][minPartition]);
262 fFCFClustersArray[minSlice][minPartition] = NULL;
263 }
264
265 fFCFClustersArray[minSlice][minPartition] = clusters;
266 fFCFNSpacePoints[minSlice][minPartition] = nSpacepoint;
267
268 HLTInfo("FCF cluster loop charge %d, slice %d partition %d\n", (UInt_t)clusters->fCharge, minSlice, minPartition);
269
270 if(nSpacepoint==0) fFCFClustersArray[minSlice][minPartition] = NULL;
271
272 } // end of loop over cluster data blocks
273
274
275
276 //----------------- loop over merged tracks -------------------//
277
278// Int_t totalTracks = 0;
279//
280// for(iter = GetFirstInputBlock(kAliHLTDataTypeTrack|kAliHLTDataOriginTPC); iter != NULL; iter = GetNextInputBlock()){
281// if(iter->fDataType != (kAliHLTDataTypeTrack|kAliHLTDataOriginTPC)) continue;
282// ReadTracks(iter,totalTracks);
283// }
284//
285// HLTDebug("TrackHisto found %d tracks", totalTracks);
286//
287// fMultiplicity->Fill(totalTracks);
288//
289// PushHisto();
290
291 return 0;
292} // end of DoEvent
293
294// void AliHLTTPCCFComparisonComponent::ReadTracks(const AliHLTComponentBlockData* iter,Int_t &tt){
295// // see header file for class documentation
296//
297// //AliHLTUInt8_t slice = AliHLTTPCDefinitions::GetMinSliceNr(*iter);
298//
299// Int_t usedSpacePoints = 0;
300//
301// vector<AliHLTGlobalBarrelTrack> tracksVector;
302// AliHLTGlobalBarrelTrack::ConvertTrackDataArray(reinterpret_cast<const AliHLTTracksData*>(iter->fPtr), iter->fSize, tracksVector);
303//
304// tt = tracksVector.size();
305//
306// for(vector<AliHLTGlobalBarrelTrack>::iterator element=tracksVector.begin(); element!=tracksVector.end(); element++){
307//
308//
309//
310//
311// UInt_t nHits = element->GetNumberOfPoints();
312// fTracks->Fill( 1./element->OneOverPt(), element->GetSnp(), element->GetTgl(), nHits );
313// //fdNdEta->Fill(element->GetSnp());
314//
315// Double_t totCharge = 0;
316// const UInt_t *hitnum = element->GetPoints();
317// for(UInt_t i=0; i<element->GetNumberOfPoints(); i++){
318//
319// UInt_t idTrack = hitnum[i];
a371a266 320// Int_t sliceTrack = AliHLTTPCSpacePointData::GetSlice(idTrack);
321// Int_t patchTrack = AliHLTTPCSpacePointData::GetPatch(idTrack);
322// UInt_t pos = AliHLTTPCSpacePointData::GetNumber(idTrack);
cfe8311c 323//
324// //printf("KKKK pos :%d\n", pos);
325// cout << "KKKK pos " << pos << endl;
326//
327// if( !fClustersArray[sliceTrack][patchTrack] ) continue;
328//
329// if(sliceTrack<0 || sliceTrack>36 || patchTrack<0 || patchTrack>5 ){
330// HLTError("Corrupted TPC cluster Id: slice %d, patch %d, cluster %d", sliceTrack, patchTrack, idTrack);
331// continue;
332// }
333//
334// if(fNSpacePoints[sliceTrack][patchTrack]<=pos ){
335// HLTError("Space point array out of boundaries!");
336// continue;
337// }
338//
339// totCharge += (fClustersArray[sliceTrack][patchTrack])[pos].fCharge;
340//
341// //Float_t xyz[3]; xyz[0] = xyz[1] = xyz[2] = 0.;
342//
343// //xyz[0] = (fClustersArray[sliceTrack][patchTrack])[pos].fX;
344// //xyz[1] = (fClustersArray[sliceTrack][patchTrack])[pos].fY;
345// //xyz[2] = (fClustersArray[sliceTrack][patchTrack])[pos].fZ;
346//
347// //AliHLTTPCTransform::Local2Global(xyz,slice);
348//
349// //Double_t p[2] = { xyz[1], xyz[2] };
350// //Double_t cov[3] = { (fClustersArray[sliceTrack][patchTrack])[pos].fSigmaY2, 0., (fClustersArray[sliceTrack][patchTrack])[pos].fSigmaZ2};
351// //Double_t *res = element->GetResiduals(p,cov,kFALSE);
352//
353// //HLTInfo("resy: %f, resz: %f", res[0], res[1]);
354//
355// //if(!res) res[0] = res[1] = -1000.;
356// //else fClusters->Fill( (fClustersArray[sliceTrack][patchTrack])[pos].fCharge, (fClustersArray[sliceTrack][patchTrack])[pos].fQMax, res[0], res[1]);
357//
358// fClusters->Fill( (fClustersArray[sliceTrack][patchTrack])[pos].fCharge, (fClustersArray[sliceTrack][patchTrack])[pos].fQMax, -1000., -1000.);
359//
360// usedSpacePoints++;
361// }
362//
363// }
364// }
365
366// void AliHLTTPCCFComparisonComponent::PushHisto(){
367// // see header file for class documentation
368//
369// PushBack( (TObject*)fTracks, kAliHLTDataTypeTNtuple |kAliHLTDataOriginTPC, 0x0);
370// PushBack( (TObject*)fClusters, kAliHLTDataTypeTNtuple |kAliHLTDataOriginTPC, 0x0);
371// PushBack( (TObject*)fMultiplicity, kAliHLTDataTypeHistogram|kAliHLTDataOriginTPC, 0x0);
372// }
373
374int AliHLTTPCCFComparisonComponent::ScanConfigurationArgument(int argc, const char** argv){
375// see header file for class documentation
376
377 if (argc<=0) return 0;
378 int i=0;
379 TString argument=argv[i];
380
381 // -event-modulo
382 if (argument.CompareTo("-event-modulo")==0) {
383 if (++i>=argc) return -EPROTO;
384 argument=argv[i];
80d83a65 385 fEvtMod=argument.Atof();
cfe8311c 386 return 2;
387 }
388
389 // -buffer-size
390 if (argument.CompareTo("-buffer-size")==0) {
391 if (++i>=argc) return -EPROTO;
392 argument=argv[i];
80d83a65 393 fBufferSize=argument.Atof();
cfe8311c 394 return 2;
395 }
396
397 return -EINVAL;
398}
399
400void AliHLTTPCCFComparisonComponent::GetOCDBObjectDescription( TMap* const targetMap){
401// Get a list of OCDB object description needed for the particular component
402 if (!targetMap) return;
403 targetMap->Add(new TObjString("HLT/ConfigTPC/TPCCFComparison"), new TObjString("component arguments for setting the size of the filled ntuples and the event modulo for the mean multiplicity distribution"));
404}