1ad6612f6551ea401a07e9c4d1904fa4c04c3114
[u/mrichter/AliRoot.git] / HLT / TPCLib / offline / AliHLTTPCOfflineClustererComponent.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 //*                                                                        *
9 //* Permission to use, copy, modify and distribute this software and its   *
10 //* documentation strictly for non-commercial purposes is hereby granted   *
11 //* without fee, provided that the above copyright notice appears in all   *
12 //* copies and that both the copyright notice and this permission notice   *
13 //* appear in the supporting documentation. The authors make no claims     *
14 //* about the suitability of this software for any purpose. It is          *
15 //* provided "as is" without express or implied warranty.                  *
16 //**************************************************************************
17
18 /** @file   AliHLTTPCOfflineClustererComponent.cxx
19     @author Matthias Richter & Jacek Otwinowski 
20     @date   
21     @brief  Wrapper component to the TPC offline cluster finder
22 */
23
24 #include "AliHLTTPCOfflineClustererComponent.h"
25 #include "AliHLTTPCDefinitions.h"
26 #include "AliCDBManager.h"
27 #include "AliGeomManager.h"
28 #include "AliTPCRecoParam.h"
29 #include "AliTPCParam.h"
30 #include "AliTPCParamSR.h"
31 #include "AliRawReaderMemory.h"
32 #include "AliTPCclustererMI.h"
33 #include "AliTPCClustersRow.h"
34 #include "AliTracker.h"
35 #include "AliDAQ.h"
36 #include "TString.h"
37 #include "TObjArray.h"
38 #include "TClonesArray.h"
39 #include "TObjString.h"
40 #include "TTree.h"
41
42 /** ROOT macro for the implementation of ROOT specific class methods */
43 ClassImp(AliHLTTPCOfflineClustererComponent)
44
45 AliHLTTPCOfflineClustererComponent::AliHLTTPCOfflineClustererComponent() 
46 : AliHLTProcessor(),
47 fOutputPercentage(100),
48 fGeometryFileName(""),
49 fTPCRecoParam(0),
50 fTPCGeomParam(0),
51 fRawReader(0),
52 fClusterer(0)
53 {
54   // Default constructor
55   fGeometryFileName = getenv("ALICE_ROOT");
56   fGeometryFileName += "/HLT/TPCLib/offline/geometry.root";
57 }
58
59 AliHLTTPCOfflineClustererComponent::~AliHLTTPCOfflineClustererComponent()
60 {
61   // Destructor
62 }
63
64 const char* AliHLTTPCOfflineClustererComponent::GetComponentID()
65 {
66   // Return component ID
67   return "TPCOfflineClusterer";
68 }
69
70 void AliHLTTPCOfflineClustererComponent::GetInputDataTypes( vector<AliHLTComponentDataType>& list)
71 {
72   // Get the list of input data types
73   list.push_back(kAliHLTDataTypeDDLRaw|kAliHLTDataOriginTPC);
74 }
75
76 AliHLTComponentDataType AliHLTTPCOfflineClustererComponent::GetOutputDataType()
77 {
78   // Return output data type
79   // TObjArray/TClonesArray of clusters
80   return  kAliHLTDataTypeTObjArray|kAliHLTDataOriginTPC/*AliHLTTPCDefinitions::fgkOfflineClustersDataType*/;
81
82 }
83
84 void AliHLTTPCOfflineClustererComponent::GetOutputDataSize(unsigned long& constBase, double& inputMultiplier)
85 {
86   // Get output data size
87   constBase = 20000;
88   inputMultiplier = ((double)fOutputPercentage)/100.0;
89 }
90
91 AliHLTComponent* AliHLTTPCOfflineClustererComponent::Spawn()
92 {
93   // Return a new instance of the class 
94   return new AliHLTTPCOfflineClustererComponent;
95 }
96
97 int AliHLTTPCOfflineClustererComponent::DoInit( int argc, const char** argv )
98 {
99   // Perfom initialisation. Checks arguments (argc,argv)  
100   // and make initialisation. Returns 0 if success.  
101   //
102 #ifdef HAVE_NOT_TPCOFFLINE_REC
103   HLTError("AliRoot version > v4-13-Release required");
104   return -ENOSYS;
105 #endif //HAVE_NOT_TPCOFFLINE_REC
106
107   int iResult=0;
108   HLTInfo("parsing %d arguments", argc);
109
110   TString argument="";
111   TString configuration=""; 
112   int bMissingParam=0;
113
114   // loop over input parameters
115   for (int i=0; i<argc && iResult>=0; i++) {
116     argument=argv[i];
117     if (argument.IsNull()) continue;
118
119     if (argument.CompareTo("-geometry")==0) {
120       if ((bMissingParam=(++i>=argc))) break;
121
122       HLTInfo("got \'-geometry\' argument: %s", argv[i]);
123       fGeometryFileName = argv[i];
124       HLTInfo("Geometry file is: %s", fGeometryFileName.c_str());
125
126       // the remaining arguments are treated as configuration
127     } else {
128       if (!configuration.IsNull()) configuration+=" ";
129       configuration+=argument;
130     }
131   } // end loop
132
133   if (bMissingParam) {
134     HLTError("missing parameter for argument %s", argument.Data());
135     iResult=-EINVAL;
136   }
137
138   if (iResult>=0 && !configuration.IsNull()) {
139     iResult=Configure(configuration.Data());
140   } else {
141     iResult=Reconfigure(NULL, NULL);
142   }
143
144   //
145   // initialisation
146   //
147    
148   // Load geometry
149   AliGeomManager::LoadGeometry(fGeometryFileName.c_str());
150   if((AliGeomManager::GetGeometry()) == 0) {
151     HLTError("Cannot load geometry from file %s",fGeometryFileName.c_str());
152     iResult=-EINVAL;
153   }
154  
155   // Raw Reader
156   fRawReader = new AliRawReaderMemory;
157
158   // TPC reconstruction parameters
159   fTPCRecoParam = AliTPCRecoParam::GetHLTParam();
160   if (fTPCRecoParam) {
161     fTPCRecoParam->SetClusterSharing(kTRUE);
162   }
163
164   // TPC geometry parameters
165   fTPCGeomParam = new AliTPCParamSR;
166   if (fTPCGeomParam) {
167     fTPCGeomParam->ReadGeoMatrices();
168   }
169
170   // Init clusterer
171   fClusterer = new AliTPCclustererMI(fTPCGeomParam,fTPCRecoParam);
172 #ifndef HAVE_NOT_TPCOFFLINE_REC
173   if (fClusterer) fClusterer->StoreInClonesArray(kTRUE); // output clusters stored in one TClonesArray
174 #endif
175
176   if (!fRawReader || !fClusterer || !fTPCRecoParam || !fTPCGeomParam) {
177     HLTError("failed creating internal objects");
178     iResult=-ENOMEM;
179   }
180   return iResult;
181 }
182
183 int AliHLTTPCOfflineClustererComponent::DoDeinit()
184 {
185   // Deinitialisation of the component
186   if (fTPCRecoParam) delete fTPCRecoParam; fTPCRecoParam=0;
187   if (fTPCGeomParam) delete fTPCGeomParam; fTPCGeomParam=0;
188   if (fRawReader) delete fRawReader; fRawReader=0;
189   if (fClusterer) delete fClusterer; fClusterer=0;
190
191   return 0;
192 }
193
194 int AliHLTTPCOfflineClustererComponent::DoEvent( const AliHLTComponentEventData& /*evtData*/, AliHLTComponentTriggerData& /*trigData*/)
195 {
196   // see header file for class documentation
197   HLTInfo("processing data");
198
199   int iResult=0;
200   int commonMinSlice=-1;
201   int commonMaxSlice=-1;
202   int commonMinPatch=-1;
203   int commonMaxPatch=-1;
204
205   for (const AliHLTComponentBlockData* pBlock=GetFirstInputBlock(kAliHLTDataTypeDDLRaw|kAliHLTDataOriginTPC);
206        pBlock!=NULL && iResult>=0;
207        pBlock=GetNextInputBlock()) {
208     int slice=AliHLTTPCDefinitions::GetMinSliceNr(pBlock->fSpecification);
209     int patch=AliHLTTPCDefinitions::GetMinPatchNr(pBlock->fSpecification);
210
211     if (slice!=AliHLTTPCDefinitions::GetMaxSliceNr(pBlock->fSpecification) ||
212             patch!=AliHLTTPCDefinitions::GetMaxPatchNr(pBlock->fSpecification)) {
213           HLTError("ambiguous readout partition (specification 0x%08x), skipping input block", pBlock->fSpecification);
214           break;
215     }
216     if (slice<0 || slice>35 || patch<0 || patch>5) {
217       HLTError("invalid readout partition %d/%d (specification 0x%08x, skipping input block", slice, patch,  pBlock->fSpecification);
218       break;
219     }
220
221     if (commonMinPatch<0) {
222       commonMinSlice=slice;
223       commonMaxSlice=slice;
224       commonMinPatch=patch;
225       commonMaxPatch=patch;
226     } else {
227       if (commonMinSlice<slice) commonMinSlice=slice;
228       if (commonMaxSlice>slice) commonMinSlice=slice;
229       if (commonMinPatch<patch) commonMinPatch=patch;
230       if (commonMaxPatch>patch) commonMinPatch=patch;
231     }
232
233     if (fRawReader && fClusterer) {
234       // setup raw reader and cluster finder
235       int ddlId=AliDAQ::DdlIDOffset("TPC");
236       if (patch<2) {
237         ddlId+=2*slice+patch;
238       } else {
239         ddlId+=72;
240         ddlId+=4*slice+patch-2;   
241       }
242
243 #ifdef HAVE_NOT_ALIRAWREADERMEMORY_ADDBUFFER
244       // AliRawReaderMemory does not support mulriple blocks, 
245       // process on block by block basis
246       fRawReader->SetMemory( reinterpret_cast<UChar_t*>( pBlock->fPtr ), pBlock->fSize );
247       fRawReader->SetEquipmentID(ddlId);
248       iResult=RunClusterer(pBlock->fSpecification);
249 #else //!HAVE_NOT_ALIRAWREADERMEMORY_ADDBUFFER
250       // add all raw data blocks to one clusterer
251       fRawReader->AddBuffer( reinterpret_cast<UChar_t*>( pBlock->fPtr ), pBlock->fSize, ddlId );
252 #endif //HAVE_NOT_ALIRAWREADERMEMORY_ADDBUFFER
253     }
254   }
255
256 #ifndef HAVE_NOT_ALIRAWREADERMEMORY_ADDBUFFER
257   iResult=RunClusterer(AliHLTTPCDefinitions::EncodeDataSpecification(commonMinSlice, 
258                                                                      commonMaxSlice,
259                                                                      commonMinPatch,
260                                                                      commonMaxPatch));
261   fRawReader->ClearBuffers();
262 #endif //HAVE_NOT_ALIRAWREADERMEMORY_ADDBUFFER
263
264   return iResult;
265 }
266
267 int AliHLTTPCOfflineClustererComponent::RunClusterer(AliHLTUInt32_t outspec)
268 {
269   // see header file for class documentation
270   int iResult=0;
271   {
272     if (fRawReader && fClusterer) {
273       // run the cluster finder
274       fClusterer->Digits2Clusters(fRawReader);
275
276       Int_t nbClusters = 0;
277       TClonesArray* outClrow=NULL;
278 #ifndef HAVE_NOT_TPCOFFLINE_REC
279       outClrow=fClusterer->GetOutputClonesArray();
280
281 #endif //HAVE_NOT_TPCOFFLINE_REC
282      
283       if (outClrow) {
284       nbClusters = outClrow->GetEntriesFast() ;
285
286       // insert TClonesArray of clusters into output stream
287       PushBack(outClrow, kAliHLTDataTypeTObjArray|kAliHLTDataOriginTPC/*AliHLTTPCDefinitions::fgkOfflineClustersDataType*/, outspec);
288
289       // clear array 
290       outClrow->Delete();
291       }
292       HLTInfo("processing done: Number of clusters %d (specification 0x%08x)", nbClusters, outspec);
293
294     } else {
295       HLTError("component not initialized");
296       iResult=-EFAULT;
297     }
298   }
299   return iResult;
300 }
301
302 int AliHLTTPCOfflineClustererComponent::Configure(const char* arguments)
303 {
304   // see header file for class documentation
305   int iResult=0;
306   if (!arguments) return iResult;
307
308   TString allArgs=arguments;
309   TString argument;
310   int bMissingParam=0;
311
312   TObjArray* pTokens=allArgs.Tokenize(" ");
313   if (pTokens) {
314     for (int i=0; i<pTokens->GetEntries() && iResult>=0; i++) {
315       argument=((TObjString*)pTokens->At(i))->GetString();
316       if (argument.IsNull()) continue;
317
318       if (argument.CompareTo("-something")==0) {
319         if ((bMissingParam=(++i>=pTokens->GetEntries()))) break;
320
321       } else {
322         HLTError("unknown argument %s", argument.Data());
323         iResult=-EINVAL;
324         break;
325       }
326     }
327     delete pTokens;
328   }
329   if (bMissingParam) {
330     HLTError("missing parameter for argument %s", argument.Data());
331     iResult=-EINVAL;
332   }
333   return iResult;
334 }
335
336 int AliHLTTPCOfflineClustererComponent::Reconfigure(const char* /*cdbEntry*/, const char* /*chainId*/)
337 {
338   // see header file for class documentation
339   int iResult=0;
340   // CDB stuff needs to be implemented
341   return iResult;
342 }