removing unused classes from repository
[u/mrichter/AliRoot.git] / HLT / TPCLib / AliHLTTPCCFComparisonComponent.cxx
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
26 using 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 */
50 ClassImp(AliHLTTPCCFComparisonComponent)
51
52 AliHLTTPCCFComparisonComponent::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
75 const char* AliHLTTPCCFComparisonComponent::fgkOCDBEntry="HLT/ConfigTPC/TPCCFComparison";
76
77 AliHLTTPCCFComparisonComponent::~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
92 const char* AliHLTTPCCFComparisonComponent::GetComponentID(){
93 // see header file for class documentation
94   
95   return "TPCCFComparison";
96 }
97
98 void 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
107 AliHLTComponentDataType AliHLTTPCCFComparisonComponent::GetOutputDataType(){
108 // see header file for class documentation
109   return kAliHLTMultipleDataType;
110 }
111
112 int 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
120 void 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
127 AliHLTComponent* AliHLTTPCCFComparisonComponent::Spawn(){
128 // see header file for class documentation
129   return new AliHLTTPCCFComparisonComponent;
130 }
131
132 int 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   
154 int 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
164 int 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
176 int 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];
320 //            Int_t sliceTrack = AliHLTTPCSpacePointData::GetSlice(idTrack);
321 //            Int_t patchTrack = AliHLTTPCSpacePointData::GetPatch(idTrack);
322 //            UInt_t pos            = AliHLTTPCSpacePointData::GetNumber(idTrack);
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
374 int 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];
385     fEvtMod=argument.Atoi();
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];
393     fBufferSize=argument.Atoi();
394     return 2;
395   }    
396    
397   return -EINVAL;
398 }
399
400 void 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 }