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