dummy reconfiguration handler added
[u/mrichter/AliRoot.git] / HLT / TPCLib / AliHLTTPCClusterFinderComponent.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: Matthias Richter <Matthias.Richter@ift.uib.no>        *
8  *                  Timm Steinbeck <timm@kip.uni-heidelberg.de>           *
9  *                  Jochen Thaeder <thaeder@kip.uni-heidelberg.de>        *
10  *                  for The ALICE HLT Project.                            *
11  *                                                                        *
12  * Permission to use, copy, modify and distribute this software and its   *
13  * documentation strictly for non-commercial purposes is hereby granted   *
14  * without fee, provided that the above copyright notice appears in all   *
15  * copies and that both the copyright notice and this permission notice   *
16  * appear in the supporting documentation. The authors make no claims     *
17  * about the suitability of this software for any purpose. It is          *
18  * provided "as is" without express or implied warranty.                  *
19  **************************************************************************/
20
21 /** @file   AliHLTTPCClusterFinderComponent.cxx
22     @author Timm Steinbeck, Matthias Richter, Jochen Thaeder, Kenneth Aamodt
23     @date   
24     @brief  The TPC cluster finder processing component
25 */
26
27 // see header file for class documentation                                   //
28 // or                                                                        //
29 // refer to README to build package                                          //
30 // or                                                                        //
31 // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt                          //
32
33 #if __GNUC__>= 3
34 using namespace std;
35 #endif
36 #include "AliHLTTPCClusterFinderComponent.h"
37 #include "AliHLTTPCDigitReaderPacked.h"
38 #include "AliHLTTPCDigitReaderUnpacked.h"
39 #include "AliHLTTPCDigitReaderRaw.h"
40 #include "AliHLTTPCClusterFinder.h"
41 #include "AliHLTTPCSpacePointData.h"
42 #include "AliHLTTPCClusterDataFormat.h"
43 #include "AliHLTTPCTransform.h"
44 #include "AliHLTTPCClusters.h"
45 #include "AliHLTTPCDefinitions.h"
46 #include "AliCDBEntry.h"
47 #include "AliCDBManager.h"
48
49 #include <cstdlib>
50 #include <cerrno>
51 #include "TString.h"
52 #include "TObjString.h"
53 #include <sys/time.h>
54
55 // this is a global object used for automatic component registration, do not use this
56 // use fPackedSwitch = true for packed inputtype "gkDDLPackedRawDataType"
57 // use fPackedSwitch = false for unpacked inputtype "gkUnpackedRawDataType"
58 AliHLTTPCClusterFinderComponent gAliHLTTPCClusterFinderComponentPacked(true);
59 AliHLTTPCClusterFinderComponent gAliHLTTPCClusterFinderComponentUnpacked(false);
60
61 /** ROOT macro for the implementation of ROOT specific class methods */
62 ClassImp(AliHLTTPCClusterFinderComponent)
63
64 AliHLTTPCClusterFinderComponent::AliHLTTPCClusterFinderComponent(bool packed)
65   :
66   fClusterFinder(NULL),
67   fReader(NULL),
68   fClusterDeconv(true),
69   fXYClusterError(-1),
70   fZClusterError(-1),
71   fPackedSwitch(packed),
72   fUnsorted(0),
73   fPatch(0),
74   fPadArray(NULL),
75   fGetActivePads(0)
76 {
77   // see header file for class documentation
78   // or
79   // refer to README to build package
80   // or
81   // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
82 }
83
84 AliHLTTPCClusterFinderComponent::~AliHLTTPCClusterFinderComponent()
85 {
86   // see header file for class documentation
87 }
88
89 // Public functions to implement AliHLTComponent's interface.
90 // These functions are required for the registration process
91
92 const char* AliHLTTPCClusterFinderComponent::GetComponentID()
93 {
94   // see header file for class documentation
95   if (fPackedSwitch) return "TPCClusterFinderPacked";
96   else return "TPCClusterFinderUnpacked";
97 }
98
99 void AliHLTTPCClusterFinderComponent::GetInputDataTypes( vector<AliHLTComponentDataType>& list)
100 {
101   // see header file for class documentation
102   list.clear(); 
103   if (fPackedSwitch) list.push_back( kAliHLTDataTypeDDLRaw | kAliHLTDataOriginTPC );
104   else list.push_back( AliHLTTPCDefinitions::fgkUnpackedRawDataType );
105    
106 }
107
108 AliHLTComponentDataType AliHLTTPCClusterFinderComponent::GetOutputDataType()
109 {
110   // see header file for class documentation
111   return kAliHLTMultipleDataType;
112 }
113
114 int AliHLTTPCClusterFinderComponent::GetOutputDataTypes(AliHLTComponentDataTypeList& tgtList)
115
116 {
117   // see header file for class documentation
118   tgtList.clear();
119   tgtList.push_back(AliHLTTPCDefinitions::fgkClustersDataType);
120   tgtList.push_back(AliHLTTPCDefinitions::fgkActivePadsDataType);
121   return tgtList.size();
122 }
123
124 void AliHLTTPCClusterFinderComponent::GetOutputDataSize( unsigned long& constBase, double& inputMultiplier )
125 {
126   // see header file for class documentation
127   // XXX TODO: Find more realistic values.  
128   constBase = 0;
129   if (fPackedSwitch)  inputMultiplier = (6 * 0.4);
130   else  inputMultiplier = 0.4;
131 }
132
133 AliHLTComponent* AliHLTTPCClusterFinderComponent::Spawn()
134 {
135   // see header file for class documentation
136   return new AliHLTTPCClusterFinderComponent(fPackedSwitch);
137 }
138         
139 int AliHLTTPCClusterFinderComponent::DoInit( int argc, const char** argv )
140 {
141   // see header file for class documentation
142   if ( fClusterFinder )
143     return EINPROGRESS;
144
145   fClusterFinder = new AliHLTTPCClusterFinder();
146
147   Int_t rawreadermode =  -1;
148   Int_t sigthresh = -1;
149   Double_t sigmathresh= -1;
150   Float_t occulimit = 1.0;
151   Int_t oldRCUFormat=0;
152   // Data Format version numbers:
153   // 0: RCU Data format as delivered during TPC commissioning, pads/padrows are sorted, RCU trailer is one 32 bit word.
154   // 1: As 0, but pads/padrows are delivered "as is", without sorting
155   // 2: As 0, but RCU trailer is 3 32 bit words.
156   // 3: As 1, but RCU trailer is 3 32 bit words.
157   // -1: use offline raw reader
158
159   Int_t i = 0;
160   Char_t* cpErr;
161
162   while ( i < argc ) {      
163
164     // -- raw reader mode option
165     if ( !strcmp( argv[i], "rawreadermode" ) ) {
166       if ( argc <= i+1 ) {
167         Logging( kHLTLogError, "HLT::TPCClusterFinder::DoInit", "Missing rawreadermode", "Raw Reader Mode not specified" );
168         return ENOTSUP;
169       }
170
171       // Decodes the rawreader mode: either number or string and returns the rawreadermode
172       // -1 on failure, -2 for offline
173       rawreadermode = AliHLTTPCDigitReaderRaw::DecodeMode( argv[i+1] );
174
175       if (rawreadermode == -1 ) {
176         Logging( kHLTLogError, "HLT::TPCClusterFinder::DoInit", "Missing rawreadermode", "Cannot convert rawreadermode specifier '%s'.", argv[i+1] );
177         return EINVAL;
178       }
179
180       i += 2;
181       continue;
182     }
183
184     // -- pp run option
185     if ( !strcmp( argv[i], "pp-run" ) ) {
186       fClusterDeconv = false;
187       i++;
188       continue;
189     }
190
191     // -- zero suppression threshold
192     if ( !strcmp( argv[i], "adc-threshold" ) ) {
193       sigthresh = strtoul( argv[i+1], &cpErr ,0);
194       if ( *cpErr ) {
195         HLTError("Cannot convert threshold specifier '%s'.", argv[i+1]);
196         return EINVAL;
197       }
198       i+=2;
199       continue;
200     }
201
202     // -- pad occupancy limit
203     if ( !strcmp( argv[i], "occupancy-limit" ) ) {
204       occulimit = strtod( argv[i+1], &cpErr);
205       if ( *cpErr ) {
206         HLTError("Cannot convert occupancy specifier '%s'.", argv[i+1]);
207         return EINVAL;
208       }
209       i+=2;
210       continue;
211     }
212
213     // -- number of timebins (default 1024)
214     if ( !strcmp( argv[i], "timebins" ) ) {
215       TString parameter(argv[i+1]);
216       parameter.Remove(TString::kLeading, ' '); // remove all blanks
217       if (parameter.IsDigit()) {
218         AliHLTTPCTransform::SetNTimeBins(parameter.Atoi());
219         HLTInfo("number of timebins set to %d, zbin=%f", AliHLTTPCTransform::GetNTimeBins(), AliHLTTPCTransform::GetZWidth());
220       } else {
221         HLTError("Cannot timebin specifier '%s'.", argv[i+1]);
222         return EINVAL;
223       }
224       i+=2;
225       continue;
226     }
227
228     // -- checking for rcu format
229     if ( !strcmp( argv[i], "oldrcuformat" ) ) {
230       oldRCUFormat = strtoul( argv[i+1], &cpErr ,0);
231       if ( *cpErr ){
232         HLTError("Cannot convert oldrcuformat specifier '%s'. Should  be 0(off) or 1(on), must be integer", argv[i+1]);
233         return EINVAL;
234       }
235       i+=2;
236       continue;
237     }
238       
239     // -- checking for unsorted clusterfinding
240     if ( !strcmp( argv[i], "unsorted" ) ) {
241       fUnsorted = strtoul( argv[i+1], &cpErr ,0);
242       if ( *cpErr ){
243         HLTError("Cannot convert unsorted specifier '%s'. Should  be 0(off) or 1(on), must be integer", argv[i+1]);
244         return EINVAL;
245       }
246       i+=2;
247       continue;
248     }
249       
250     // -- checking for active pads, used in 2007 December run
251     if ( !strcmp( argv[i], "activepads" ) ) {
252       fGetActivePads = strtoul( argv[i+1], &cpErr ,0);
253       if ( *cpErr ){
254         HLTError("Cannot convert activepads specifier '%s'. Should  be 0(off) or 1(on), must be integer", argv[i+1]);
255         return EINVAL;
256       }
257       i+=2;
258       continue;
259     }
260
261     // -- checking for nsigma-threshold, used in 2007 December run in ZeroSuppression
262     if ( !strcmp( argv[i], "nsigma-threshold" ) ) {
263        sigmathresh = strtoul( argv[i+1], &cpErr ,0);
264       if ( *cpErr ){
265         HLTError("Cannot convert nsigma-threshold specifier '%s'. Must be integer", argv[i+1]);
266         return EINVAL;
267       }
268       i+=2;
269       continue;
270     }
271
272     Logging(kHLTLogError, "HLT::TPCClusterFinder::DoInit", "Unknown Option", "Unknown option '%s'", argv[i] );
273     return EINVAL;
274
275   }
276
277   // Choose reader
278
279   if (fPackedSwitch) { 
280     if (rawreadermode == -2) {
281       HLTDebug("using AliHLTTPCDigitReaderPacked");
282       fReader = new AliHLTTPCDigitReaderPacked();
283       if(oldRCUFormat==1){
284         fReader->SetOldRCUFormat(kTRUE);
285       }
286       else if(oldRCUFormat!=0){
287         HLTWarning("Wrong oldrcuformat specifier %d; oldrcuformat set to default(kFALSE)",oldRCUFormat);
288       }
289       if(fUnsorted==1){
290         fReader->SetUnsorted(kTRUE);
291       }
292       fClusterFinder->SetReader(fReader);
293     } else {
294 #if defined(HAVE_TPC_MAPPING)
295       HLTDebug("using AliHLTTPCDigitReaderRaw mode %d", rawreadermode);
296       fReader = new AliHLTTPCDigitReaderRaw(rawreadermode);
297       fClusterFinder->SetReader(fReader);
298 #else //! defined(HAVE_TPC_MAPPING)
299       HLTFatal("DigitReaderRaw not available - check your build");
300       return -ENODEV;
301 #endif //defined(HAVE_TPC_MAPPING)
302     }
303   }
304   else {
305     HLTDebug("using AliHLTTPCDigitReaderUnpacked");
306     fReader = new AliHLTTPCDigitReaderUnpacked();
307     fClusterFinder->SetReader(fReader);
308   }
309
310   // if pp-run use occupancy limit else set to 1. ==> use all 
311   if ( !fClusterDeconv )
312     fClusterFinder->SetOccupancyLimit(occulimit);
313   else 
314     fClusterFinder->SetOccupancyLimit(1.0);
315       
316   // Variables to setup the Clusterfinder
317   // TODO: this sounds strange and has to be verified; is the cluster finder not working when
318   // fClusterDeconv = false ?
319   fClusterDeconv = true;
320   fXYClusterError = -1;
321   fZClusterError = -1;
322
323  
324   fClusterFinder->SetDeconv( fClusterDeconv );
325   fClusterFinder->SetXYError( fXYClusterError );
326   fClusterFinder->SetZError( fZClusterError );
327   if ( (fXYClusterError>0) && (fZClusterError>0) )
328     fClusterFinder->SetCalcErr( false );
329   fClusterFinder->SetSignalThreshold(sigthresh);
330   fClusterFinder->SetNSigmaThreshold(sigmathresh);
331
332   return 0;
333 }
334
335 int AliHLTTPCClusterFinderComponent::DoDeinit()
336 {
337   // see header file for class documentation
338
339   if ( fClusterFinder )
340     delete fClusterFinder;
341   fClusterFinder = NULL;
342  
343   if ( fReader )
344     delete fReader;
345   fReader = NULL;
346     
347   return 0;
348 }
349
350 int AliHLTTPCClusterFinderComponent::DoEvent( const AliHLTComponentEventData& evtData, 
351                                               const AliHLTComponentBlockData* blocks, 
352                                               AliHLTComponentTriggerData& /*trigData*/, AliHLTUInt8_t* outputPtr, 
353                                               AliHLTUInt32_t& size, 
354                                               vector<AliHLTComponentBlockData>& outputBlocks )
355 {
356   // see header file for class documentation
357
358   //  == init iter (pointer to datablock)
359   const AliHLTComponentBlockData* iter = NULL;
360   unsigned long ndx;
361
362   //  == OUTdatatype pointer
363   AliHLTTPCClusterData* outPtr;
364
365   AliHLTUInt8_t* outBPtr;
366   UInt_t offset, mysize, nSize, tSize = 0;
367
368   outBPtr = outputPtr;
369   outPtr = (AliHLTTPCClusterData*)outBPtr;
370
371   Int_t slice, patch, row[2];
372   unsigned long maxPoints, realPoints = 0;
373
374   for ( ndx = 0; ndx < evtData.fBlockCnt; ndx++ )
375     {
376       iter = blocks+ndx;
377       mysize = 0;
378       offset = tSize;
379
380
381       if (fPackedSwitch) {
382         HLTDebug("Event 0x%08LX (%Lu) received datatype: %s - required datatype: %s",
383                  evtData.fEventID, evtData.fEventID, 
384                  DataType2Text( iter->fDataType).c_str(), 
385                  DataType2Text(kAliHLTDataTypeDDLRaw | kAliHLTDataOriginTPC).c_str());
386
387         if (iter->fDataType == AliHLTTPCDefinitions::fgkDDLPackedRawDataType &&
388             GetEventCount()<2) {
389           HLTWarning("data type %s is depricated, use %s (kAliHLTDataTypeDDLRaw)!",
390                      DataType2Text(AliHLTTPCDefinitions::fgkDDLPackedRawDataType).c_str(),
391                      DataType2Text(kAliHLTDataTypeDDLRaw | kAliHLTDataOriginTPC).c_str());
392           }
393
394         if ( iter->fDataType != (kAliHLTDataTypeDDLRaw | kAliHLTDataOriginTPC) &&
395              iter->fDataType != AliHLTTPCDefinitions::fgkDDLPackedRawDataType ) continue;
396
397       }
398       else {
399         HLTDebug("Event 0x%08LX (%Lu) received datatype: %s - required datatype: %s",
400                  evtData.fEventID, evtData.fEventID, 
401                  DataType2Text( iter->fDataType).c_str(), 
402                  DataType2Text(AliHLTTPCDefinitions::fgkUnpackedRawDataType).c_str());
403
404         if ( iter->fDataType != AliHLTTPCDefinitions::fgkUnpackedRawDataType ) continue;
405
406       }
407         
408       slice = AliHLTTPCDefinitions::GetMinSliceNr( *iter );
409       patch = AliHLTTPCDefinitions::GetMinPatchNr( *iter );
410       row[0] = AliHLTTPCTransform::GetFirstRow( patch );
411       row[1] = AliHLTTPCTransform::GetLastRow( patch );
412         
413       if(fUnsorted){
414         if(fPadArray==NULL){
415           fClusterFinder->SetUnsorted(fUnsorted);
416           fPadArray = new AliHLTTPCPadArray(patch);
417           fPadArray->InitializeVector();
418         }
419         else if(fPadArray->GetPatch()!=patch||fPadArray->GetPatch()==-1){
420           if (GetEventCount()<3) {
421             HLTWarning("pad array not initialized for data of specification 0x%08x, block skipped", iter->fSpecification);
422           } else if ((GetEventCount()%5000)==0) { // assuming 0.5 to 1kHz this gives a message rate of 0.1 to 0.5 Hz
423             HLTWarning("reminder: pad array not initialized for data of specification 0x%08x", iter->fSpecification);
424           }
425           continue;
426         }
427       }
428
429       outPtr = (AliHLTTPCClusterData*)outBPtr;
430
431       maxPoints = (size-tSize-sizeof(AliHLTTPCClusterData))/sizeof(AliHLTTPCSpacePointData);
432
433       fClusterFinder->InitSlice( slice, patch, row[0], row[1], maxPoints );
434       fClusterFinder->SetOutputArray( (AliHLTTPCSpacePointData*)outPtr->fSpacePoints );
435         
436       if(fUnsorted){
437
438
439         fClusterFinder->SetPadArray(fPadArray);
440         /*        
441         double totalT=0;
442         struct timeval startT, endT;
443         gettimeofday( &startT, NULL );
444         */
445         fClusterFinder->ReadDataUnsorted(iter->fPtr, iter->fSize );
446         /*
447         gettimeofday( &endT, NULL );
448         unsigned long long dt;
449         dt = endT.tv_sec-startT.tv_sec;
450         dt *= 1000000ULL;
451         dt += endT.tv_usec-startT.tv_usec;
452         double dtd = ((double)dt);
453         totalT += dtd;
454         //        dtd = dtd / (double)eventIterations;
455         //        if ( iterations<=1 )
456         cout<<endl;
457         printf( "Time needed to read data: %f microsec. / %f millisec. / %f s\n", 
458                 dtd, dtd/1000.0, dtd/1000000.0 );
459           
460         cout<<endl;
461         */
462         fClusterFinder->FindClusters();
463       }
464       else{
465         fClusterFinder->Read(iter->fPtr, iter->fSize );
466         fClusterFinder->ProcessDigits();
467       }
468       realPoints = fClusterFinder->GetNumberOfClusters();
469         
470       outPtr->fSpacePointCnt = realPoints;
471       nSize = sizeof(AliHLTTPCSpacePointData)*realPoints;
472       mysize += nSize+sizeof(AliHLTTPCClusterData);
473
474       Logging( kHLTLogDebug, "HLT::TPCClusterFinder::DoEvent", "Spacepoints", 
475                "Number of spacepoints: %lu Slice/Patch/RowMin/RowMax: %d/%d/%d/%d.",
476                realPoints, slice, patch, row[0], row[1] );
477       AliHLTComponentBlockData bd;
478       FillBlockData( bd );
479       bd.fOffset = offset;
480       bd.fSize = mysize;
481       bd.fSpecification = iter->fSpecification;
482       bd.fDataType = AliHLTTPCDefinitions::fgkClustersDataType;
483       //AliHLTSubEventDescriptor::FillBlockAttributes( bd.fAttributes );
484       outputBlocks.push_back( bd );
485         
486       tSize += mysize;
487       outBPtr += mysize;
488       outPtr = (AliHLTTPCClusterData*)outBPtr;
489         
490       if(fGetActivePads){
491         AliHLTTPCPadArray::AliHLTTPCActivePads* outPtrActive;
492         UInt_t activePadsSize, activePadsN = 0;
493         outPtrActive = (AliHLTTPCPadArray::AliHLTTPCActivePads*)outBPtr;
494         offset=tSize;
495         Int_t maxActivePads = (size-tSize)/sizeof(AliHLTTPCPadArray::AliHLTTPCActivePads);
496         activePadsSize= fClusterFinder->GetActivePads((AliHLTTPCPadArray::AliHLTTPCActivePads*)outPtrActive,maxActivePads)*sizeof(AliHLTTPCPadArray::AliHLTTPCActivePads);
497         
498         AliHLTComponentBlockData bdActive;
499         FillBlockData( bdActive );
500         bdActive.fOffset = offset;
501         bdActive.fSize = activePadsSize;
502         bdActive.fSpecification = iter->fSpecification;
503         bdActive.fDataType = AliHLTTPCDefinitions::fgkActivePadsDataType;
504         outputBlocks.push_back( bdActive );
505         
506         tSize+=activePadsSize;
507         outBPtr += activePadsSize;
508         outPtrActive = (AliHLTTPCPadArray::AliHLTTPCActivePads*)outBPtr;
509       }
510  
511
512       if ( tSize > size )
513         {
514           Logging( kHLTLogFatal, "HLT::TPCClusterFinder::DoEvent", "Too much data", 
515                    "Data written over allowed buffer. Amount written: %lu, allowed amount: %lu.",
516                    tSize, size );
517           return EMSGSIZE;
518         }
519     }
520     
521   size = tSize;
522
523   return 0;
524 }
525
526 int AliHLTTPCClusterFinderComponent::Reconfigure(const char* cdbEntry, const char* chainId)
527 {
528   // see header file for class documentation
529   const char* path="HLT/ConfigTPC";
530   if (cdbEntry) path=cdbEntry;
531   if (path) {
532     HLTInfo("reconfigure from entry %s, chain id %s", path, (chainId!=NULL && chainId[0]!=0)?chainId:"<none>");
533     AliCDBEntry *pEntry = AliCDBManager::Instance()->Get(path/*,GetRunNo()*/);
534     if (pEntry) {
535       TObjString* pString=dynamic_cast<TObjString*>(pEntry->GetObject());
536       if (pString) {
537         HLTInfo("received configuration object: %s", pString->GetString().Data());
538       } else {
539         HLTError("configuration object \"%s\" has wrong type, required TObjString", path);
540       }
541     } else {
542       HLTError("can not fetch object \"%s\" from CDB", path);
543     }
544   }
545 }