]> git.uio.no Git - u/mrichter/AliRoot.git/blob - HLT/TPCLib/AliHLTTPCHWClusterTransformComponent.cxx
cleaning memory on error condition and loop break
[u/mrichter/AliRoot.git] / HLT / TPCLib / AliHLTTPCHWClusterTransformComponent.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   AliHLTTPCHWClusterTransformComponent.cxx
20     @author Kalliopi Kanaki
21     @date   
22     @brief 
23 */
24
25 #if __GNUC__>= 3
26 using namespace std;
27 #endif
28 #include "AliHLTTPCHWClusterTransformComponent.h"
29 #include "AliHLTTPCDefinitions.h"
30 #include "AliHLTTPCTransform.h"
31 #include "AliHLTTPCSpacePointData.h"
32 #include "AliHLTTPCClusterDataFormat.h"
33
34 #include "AliCDBManager.h"
35 #include "AliCDBEntry.h"
36 #include "AliTPCcalibDB.h"
37
38 #include "TMath.h"
39 #include "TObjString.h" 
40 #include <cstdlib>
41 #include <cerrno>
42 #include <sys/time.h>
43
44 ClassImp(AliHLTTPCHWClusterTransformComponent) //ROOT macro for the implementation of ROOT specific class methods
45
46 const char* AliHLTTPCHWClusterTransformComponent::fgkOCDBEntryHWTransform="HLT/ConfigTPC/TPCHWClusterTransform";
47
48 AliHLTTPCHWClusterTransformComponent::AliHLTTPCHWClusterTransformComponent()
49 :
50 fDataId(kFALSE),
51 fChargeThreshold(10),
52 fTransform(),
53 fBenchmark("HWClusterTransform")
54 {
55   // see header file for class documentation
56   // or
57   // refer to README to build package
58   // or
59   // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt  
60
61   fBenchmark.Reset();
62   fBenchmark.SetTimer(0,"total");
63 }
64
65 AliHLTTPCHWClusterTransformComponent::~AliHLTTPCHWClusterTransformComponent() { 
66 // see header file for class documentation
67 }
68
69 const char* AliHLTTPCHWClusterTransformComponent::GetComponentID() { 
70 // see header file for class documentation
71
72   return "TPCHWClusterTransform";
73 }
74
75 void AliHLTTPCHWClusterTransformComponent::GetInputDataTypes( vector<AliHLTComponentDataType>& list) { 
76   // see header file for class documentation
77
78   list.clear(); 
79   list.push_back( AliHLTTPCDefinitions::fgkHWClustersDataType );
80 }
81
82 AliHLTComponentDataType AliHLTTPCHWClusterTransformComponent::GetOutputDataType() { 
83   // see header file for class documentation
84
85   return AliHLTTPCDefinitions::fgkClustersDataType;
86 }
87
88 int AliHLTTPCHWClusterTransformComponent::GetOutputDataTypes(AliHLTComponentDataTypeList& tgtList) { 
89   // see header file for class documentation
90
91   tgtList.clear();
92   tgtList.push_back(AliHLTTPCDefinitions::fgkClustersDataType);
93   return tgtList.size();
94 }
95
96 void AliHLTTPCHWClusterTransformComponent::GetOutputDataSize( unsigned long& constBase, double& inputMultiplier ) { 
97   // see header file for class documentation
98   constBase = 0;
99   inputMultiplier = 3.0;
100 }
101
102 AliHLTComponent* AliHLTTPCHWClusterTransformComponent::Spawn() { 
103   // see header file for class documentation
104
105   return new AliHLTTPCHWClusterTransformComponent();
106 }
107         
108 int AliHLTTPCHWClusterTransformComponent::DoInit( int argc, const char** argv ) { 
109 // see header file for class documentation
110   
111   AliTPCcalibDB *calib=AliTPCcalibDB::Instance();  
112   if(!calib){
113     HLTError("AliTPCcalibDB does not exist");
114     return -ENOENT;
115   }
116   calib->SetRun(GetRunNo());
117   calib->UpdateRunInformations(GetRunNo());
118
119   int err = fTransform.Init( GetBz(), GetTimeStamp() );
120
121   if( err!=0 ){
122     HLTError("Cannot retrieve offline transform from AliTPCcalibDB");
123     return -ENOENT;
124   }
125
126   int iResult=0;
127   iResult = ConfigureFromCDBTObjString(fgkOCDBEntryHWTransform);
128
129   if (iResult>=0 && argc>0)
130     iResult=ConfigureFromArgumentString(argc, argv);
131
132   return iResult;
133 } // end DoInit()
134
135 int AliHLTTPCHWClusterTransformComponent::DoDeinit() { 
136   // see header file for class documentation   
137   return 0;
138 }
139
140 int AliHLTTPCHWClusterTransformComponent::DoEvent(const AliHLTComponentEventData& evtData, 
141                                                   const AliHLTComponentBlockData* blocks, 
142                                                   AliHLTComponentTriggerData& /*trigData*/, AliHLTUInt8_t* outputPtr, 
143                                                   AliHLTUInt32_t& size, 
144                                                   vector<AliHLTComponentBlockData>& outputBlocks ){
145   // see header file for class documentation
146    
147   if(GetFirstInputBlock( kAliHLTDataTypeSOR ) || GetFirstInputBlock( kAliHLTDataTypeEOR )){
148      size = 0;
149      return 0;
150   }
151
152   fBenchmark.StartNewEvent();
153   fBenchmark.Start(0);
154
155   fTransform.SetCurrentTimeStamp( GetTimeStamp() );
156
157   const AliHLTComponentBlockData *iter = NULL;    
158   unsigned long ndx; 
159
160   AliHLTUInt8_t* outBPtr;
161   UInt_t offset, mysize, nSize, tSize = 0;
162
163   outBPtr = outputPtr;
164       
165   for(ndx=0; ndx<evtData.fBlockCnt; ndx++){
166      
167      iter   = blocks+ndx;
168      mysize = 0;
169      offset = tSize;
170      
171      fBenchmark.AddInput(iter->fSize);
172
173      HLTDebug("Event 0x%08LX (%Lu) received datatype: %s - required datatype: %s",
174                evtData.fEventID, evtData.fEventID, 
175                DataType2Text( iter->fDataType).c_str(), 
176                DataType2Text(AliHLTTPCDefinitions::fgkHWClustersDataType).c_str());                       
177  
178      if(iter->fDataType != AliHLTTPCDefinitions::fgkHWClustersDataType) continue;                        
179   
180      UInt_t minSlice     = AliHLTTPCDefinitions::GetMinSliceNr(*iter); 
181      UInt_t minPartition = AliHLTTPCDefinitions::GetMinPatchNr(*iter);
182      //UInt_t maxSlice     = AliHLTTPCDefinitions::GetMaxSliceNr(*iter); 
183      //UInt_t maxPartition = AliHLTTPCDefinitions::GetMaxPatchNr(*iter);
184
185      fBenchmark.SetName(Form("HWClusterTransform slice %d patch %d",minSlice,minPartition));
186
187      HLTDebug("minSlice: %d, minPartition: %d", minSlice, minPartition);
188     
189      AliHLTTPCClusterData* outPtr  = (AliHLTTPCClusterData*)outBPtr;
190
191      unsigned long maxPoints = (size-tSize-sizeof(AliHLTTPCClusterData))/sizeof(AliHLTTPCSpacePointData);
192      
193      AliHLTUInt32_t *buffer;     
194      buffer = (AliHLTUInt32_t*)iter->fPtr;  
195      
196      /*  
197      //cluster fabrication
198      buffer = new AliHLTUInt32_t[14];
199      //header
200      buffer[0]=0xffffffff;
201      buffer[1]=0xffffffff;
202      buffer[2]=0xffffffff;
203      buffer[3]=0xffffffff;
204      buffer[4]=0xffffffff;
205      buffer[5]=0xffffffff;
206      buffer[6]=0xffffffff;
207      buffer[7]=0xffffffff;
208      //cluster 1
209      buffer[8]=0xC60002EF;
210      buffer[9]=0x0;
211      buffer[10]=0x0;
212      buffer[11]=0x0;
213      buffer[12]=0x0;
214      //RCU trailer
215      buffer[13]=0x80000000;
216      */
217
218      // PrintDebug(buffer, 14);
219      
220      // skip the first 8 32-bit CDH words
221      buffer += 8;
222
223      //PrintDebug(buffer, (Int_t)iter->fSize/sizeof(AliHLTUInt32_t));
224
225      unsigned long nAddedClusters = 0;
226      
227      for(UInt_t nWords=0; nWords<(iter->fSize/sizeof(AliHLTUInt32_t)); nWords+=5){
228      //     for(UInt_t nWords=0; nWords<5; nWords+=5){
229
230         // check if bit 31 and 30 of the 32-bit word is 11 -> cluster (10 is RCU trailer)
231         AliHLTUInt32_t bit3130 = (buffer[nWords]>>30); // shift 30 to the right
232        
233
234         if(bit3130 == 0x3){ //beginning of a cluster
235
236            //PrintDebug(&buffer[nWords], 5);
237           
238            if(nAddedClusters>=maxPoints){
239               HLTWarning("No more space to add clusters, exiting!");
240               break;
241            }
242
243            
244            AliHLTTPCSpacePointData cluster = { 0.,0.,0.,0,0,0.,0.,0,0,kFALSE,0 };
245               
246            //get the first word
247            AliHLTUInt32_t  rowCharge = buffer[nWords];
248            AliHLTUInt8_t  *rowPtr    = reinterpret_cast<AliHLTUInt8_t*>(&rowCharge);      
249            rowPtr+=3; // this is to run for little endian architecture, the word is read from right to left
250         
251            cluster.fPadRow  = (UChar_t)((*rowPtr)&0x3f);
252            cluster.fCharge  = ((UInt_t)rowCharge&0xFFFFFF)>>6; //24-bit mask to get out the charge and division with 64(>>6) for the gain correction
253
254            Float_t tmpPad   = *((Float_t*)&buffer[nWords+1]);
255            Float_t tmpTime  = *((Float_t*)&buffer[nWords+2]);
256            cluster.fSigmaY2 = *((Float_t*)&buffer[nWords+3]);
257            cluster.fSigmaZ2 = *((Float_t*)&buffer[nWords+4]);
258            
259            
260            if(cluster.fCharge<fChargeThreshold) continue;
261            
262            // correct expressions for the error calculation
263            // Kenneth: 12.11.2009 I'm not sure if this is a correct calculation. Leave it out for now since it is anyway not used later since it caused segfaults.
264            // cluster.fSigmaY2 = TMath::Sqrt( *((Float_t*)&buffer[nWords+3]) - *((Float_t*)&buffer[nWords+1])* (*((Float_t*)&buffer[nWords+1])) );
265            // cluster.fSigmaZ2 = TMath::Sqrt( *((Float_t*)&buffer[nWords+3]) - *((Float_t*)&buffer[nWords+1])* (*((Float_t*)&buffer[nWords+1])) );
266                    
267            HLTDebug("padrow: %d, charge: %d, pad: %f, time: %f, errY: %f, errZ: %f \n", cluster.fPadRow, (UInt_t)cluster.fCharge, tmpPad, tmpTime, cluster.fSigmaY2, cluster.fSigmaZ2);            
268                     
269            cluster.fPadRow += AliHLTTPCTransform::GetFirstRow(minPartition);                 
270               
271            Float_t xyz[3];
272            fTransform.Transform( minSlice, cluster.fPadRow, tmpPad, tmpTime, xyz );
273            cluster.fX = xyz[0];
274            cluster.fY = xyz[1];
275            cluster.fZ = xyz[2];                            
276
277            // set the cluster ID so that the cluster dump printout is the same for FCF and SCF
278            cluster.SetID( minSlice, minPartition, nAddedClusters );
279
280            HLTDebug("Cluster number %d: %f, Y: %f, Z: %f, charge: %d \n", nAddedClusters, cluster.fX, cluster.fY, cluster.fZ, (UInt_t)cluster.fCharge);
281            outPtr->fSpacePoints[nAddedClusters] = cluster;
282                    
283            nAddedClusters++; 
284         } // end of clusters starting with 11=0x3
285         else if(bit3130 == 0x2){ // we have reached the beginning of the RCU trailer - 10=0x2
286           break;
287         }
288      } // end of loop over clusters
289      
290      HLTDebug("Number of found clusters: %d", nAddedClusters);
291      
292      outPtr->fSpacePointCnt = nAddedClusters;
293      nSize = sizeof(AliHLTTPCSpacePointData)*outPtr->fSpacePointCnt;
294      mysize += nSize+sizeof(AliHLTTPCClusterData);
295  
296      AliHLTComponentBlockData bd;
297      FillBlockData( bd );
298      bd.fOffset = offset;
299      bd.fSize = mysize;
300      bd.fSpecification = iter->fSpecification;
301      
302      if(fDataId==kFALSE) bd.fDataType = AliHLTTPCDefinitions::fgkClustersDataType;
303      else                bd.fDataType = AliHLTTPCDefinitions::fgkAlterClustersDataType;
304      
305      //HLTDebug("datatype: %s", DataType2Text(bd.fDataType).c_str());
306      
307      outputBlocks.push_back( bd );
308      
309      fBenchmark.AddOutput(bd.fSize);
310     
311      tSize   += mysize;
312      outBPtr += mysize;
313   
314    } // end of loop over data blocks
315
316   size = tSize;
317   
318   fBenchmark.Stop(0);
319   HLTInfo(fBenchmark.GetStatistics());
320
321   return 0;
322 } // end DoEvent()
323
324 int AliHLTTPCHWClusterTransformComponent::ScanConfigurationArgument(int argc, const char** argv){
325
326   // see header file for class documentation
327
328   if (argc<=0) return 0;
329   int i=0;
330   TString argument=argv[i];
331
332   if (argument.CompareTo("-solenoidBz")==0){
333     if (++i>=argc) return -EPROTO;
334     argument=argv[i];
335     AliTPCcalibDB*  calib=AliTPCcalibDB::Instance();
336     if(!calib){
337       HLTError("CalibDB not available");
338     }
339     Float_t magneticField = argument.Atof();
340     calib->SetExBField(magneticField);
341     HLTInfo("SolenoidBz is set to %f in the calibDB",magneticField);
342     return 2;
343   }
344
345   if (argument.CompareTo("-change-dataId")==0){
346     HLTDebug("Change data ID received.");
347     fDataId = kTRUE;
348     return 1;
349   }
350   
351   if (argument.CompareTo("-charge-threshold")==0) {
352     if (++i>=argc) return -EPROTO;
353     argument=argv[i];
354     fChargeThreshold=(UInt_t)argument.Atoi();
355     HLTInfo("The charge threshold has been set to %d.", fChargeThreshold);
356     return 2;
357   }    
358
359   // unknown argument
360   return -EINVAL;
361 }
362
363 int AliHLTTPCHWClusterTransformComponent::Reconfigure(const char* /*cdbEntry*/, const char* /*chainId*/) { 
364   // see header file for class documentation
365   return ConfigureFromCDBTObjString(fgkOCDBEntryHWTransform);
366 }
367
368 void AliHLTTPCHWClusterTransformComponent::PrintDebug(AliHLTUInt32_t *buffer, Int_t size){
369 // see header file for class documentation 
370
371   HLTInfo("The size is: %d", size);
372   for(Int_t n32bit=0; n32bit<size; n32bit++){
373     
374     AliHLTUInt8_t *wordPtr = reinterpret_cast<AliHLTUInt8_t*>(&buffer[n32bit]);
375     //    cout << "word ptr initialized"<<endl;
376     for(Int_t w=3;w>=0;w--){
377       //     cout <<"accessing word"<<endl;
378       AliHLTUInt8_t word = wordPtr[w];
379       //     cout<< "word was accessed"<<endl; 
380       for(int n=7; n>=0; n--){
381         //print the byte values
382         if((((word>>n)<<7)&0x80) != 0){
383           printf("1");
384         }
385         else{
386           printf("0");
387         }
388       }
389       printf("  ");
390     }
391     printf("\n");
392   }
393 } // end of PrintDebug
394
395 void AliHLTTPCHWClusterTransformComponent::GetOCDBObjectDescription( TMap* const targetMap){
396 // Get a list of OCDB object description needed for the particular component
397   if (!targetMap) return;
398   targetMap->Add(new TObjString("HLT/ConfigTPC/TPCHWClusterTransform"), new TObjString("component argument for the charge threshold"));
399 }