5991104a77baba6b94c911a30d61dc2669200e65
[u/mrichter/AliRoot.git] / HLT / TRD / AliHLTTRDTrackerComponent.cxx
1 // $Id$
2
3 /**************************************************************************
4  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
5  *                                                                        *
6  * Authors: Matthias Richter <Matthias.Richter@ift.uib.no>                *
7  *          Timm Steinbeck <timm@kip.uni-heidelberg.de>                   *
8  *          for The ALICE Off-line 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   AliHLTTRDTrackerComponent.cxx
20     @author Timm Steinbeck, Matthias Richter
21     @date   
22     @brief  A TRDTracker processing component for the HLT. */
23
24 #if __GNUC__ >= 3
25 using namespace std;
26 #endif
27
28 #include "TFile.h"
29 #include "TChain.h"
30
31 #include "AliHLTTRDTrackerComponent.h"
32 #include "AliHLTTRDDefinitions.h"
33 #include "AliCDBManager.h"
34
35 #include "AliTRDReconstructor.h"
36 #include "AliTRDrecoParam.h"
37 #include "AliESDEvent.h"
38 //#include "AliTRDtrackerHLT.h"
39 #include "AliTRDtracker.h"
40 #include "AliTRDCalibraFillHisto.h"
41 #include "AliMagFMaps.h"
42 #include "AliTRDcluster.h"
43 #include "AliESDfriend.h"
44 #include <cstdlib>
45 #include <cerrno>
46 #include <string>
47
48 // this is a global object used for automatic component registration, do not use this
49 AliHLTTRDTrackerComponent gAliHLTTRDTrackerComponent;
50
51 ClassImp(AliHLTTRDTrackerComponent);
52     
53 AliHLTTRDTrackerComponent::AliHLTTRDTrackerComponent()
54   : AliHLTProcessor()
55   , fOutputPercentage(100) // By default we copy to the output exactly what we got as input  
56   , fStrorageDBpath("local://$ALICE_ROOT")
57   , fCDB(NULL)
58   , fField(NULL)
59   , fGeometryFileName("")
60   , fGeometryFile(NULL)
61   , fGeoManager(NULL)
62   , fTracker(NULL)
63 {
64   // Default constructor
65
66   fGeometryFileName = getenv("ALICE_ROOT");
67   fGeometryFileName += "/HLT/TRD/geometry.root";
68 }
69
70 AliHLTTRDTrackerComponent::~AliHLTTRDTrackerComponent()
71 {
72   // Destructor
73 }
74
75 const char* AliHLTTRDTrackerComponent::GetComponentID()
76 {
77   // Return the component ID const char *
78   return "TRDTracker"; // The ID of this component
79 }
80
81 void AliHLTTRDTrackerComponent::GetInputDataTypes( vector<AliHLTComponent_DataType>& list)
82 {
83   // Get the list of input data  
84   list.clear(); // We do not have any requirements for our input data type(s).
85   list.push_back( AliHLTTRDDefinitions::fgkClusterDataType );
86 }
87
88 AliHLTComponent_DataType AliHLTTRDTrackerComponent::GetOutputDataType()
89 {
90   // Get the output data type
91   return AliHLTTRDDefinitions::fgkClusterDataType;
92 }
93
94 void AliHLTTRDTrackerComponent::GetOutputDataSize( unsigned long& constBase, double& inputMultiplier )
95 {
96   // Get the output data size
97   constBase = 0;
98   inputMultiplier = ((double)fOutputPercentage)/100.0;
99 }
100
101 // Spawn function, return new instance of this class
102 AliHLTComponent* AliHLTTRDTrackerComponent::Spawn()
103 {
104   // Spawn function, return new instance of this class
105   return new AliHLTTRDTrackerComponent;
106 };
107
108 int AliHLTTRDTrackerComponent::DoInit( int argc, const char** argv )
109 {
110   // perform initialization. We check whether our relative output size is specified in the arguments.
111   fOutputPercentage = 100;
112   int i = 0;
113   char* cpErr;
114   while ( i < argc )
115     {
116       HLTDebug("argv[%d] == %s", i, argv[i] );
117       if ( !strcmp( argv[i], "output_percentage" ) )
118         {
119           if ( i+1>=argc )
120             {
121               HLTError("Missing output_percentage parameter");
122               return ENOTSUP;
123             }
124           HLTDebug("Arguments", "argv[%d+1] == %s", i, argv[i+1] );
125           fOutputPercentage = strtoul( argv[i+1], &cpErr, 0 );
126           if ( *cpErr )
127             {
128               HLTError("Cannot convert output_percentage parameter '%s'", argv[i+1] );
129               return EINVAL;
130             }
131           HLTInfo("Output percentage set to %lu %%", fOutputPercentage );
132           i += 2;
133           continue;
134         }
135
136       if ( strcmp( argv[i], "-cdb" ) == 0)
137         {
138           if ( i+1 >= argc )
139             {
140               HLTError("Missing -cdb argument");
141               return ENOTSUP;         
142             }
143           fStrorageDBpath = argv[i+1];
144           HLTInfo("DB storage is %s", fStrorageDBpath.c_str() );          
145           i += 2;
146           continue;
147         }      
148
149       if ( strcmp( argv[i], "-geometry" ) == 0)
150         {
151           if ( i+1 >= argc )
152             {
153               HLTError("Missing -geometry argument");
154               return ENOTSUP;         
155             }
156           fGeometryFileName = argv[i+1];
157           HLTInfo("GeomFile storage is %s", fGeometryFileName.c_str() );          
158           i += 2;
159           continue;
160         }      
161
162       HLTError("Unknown option '%s'", argv[i] );
163       return EINVAL;
164     }
165
166   //init alifield map - temporarly fixed - should come from a DB
167   fField = new AliMagFMaps("Maps","Maps", 2, 1., 10., 1);
168   if (fField)
169     AliTracker::SetFieldMap(fField,1);
170   else
171     HLTError("Unable to init the field");
172
173   fCDB = AliCDBManager::Instance();
174   if (!fCDB)
175     {
176       HLTError("Could not get CDB instance", "fCDB 0x%x", fCDB);
177     }
178   else
179     {
180       fCDB->SetRun(0); // THIS HAS TO BE RETRIEVED !!!
181       fCDB->SetDefaultStorage(fStrorageDBpath.c_str());
182       HLTDebug("fCDB 0x%x", fCDB);
183     }
184     
185   fGeometryFile = TFile::Open(fGeometryFileName.c_str());
186   if (fGeometryFile)
187     {
188       fGeoManager = (TGeoManager *)fGeometryFile->Get("Geometry");
189       //fTracker = new AliTRDtrackerHLT(fGeometryFile);
190       AliTRDrecoParam *fPars = AliTRDrecoParam::GetLowFluxParam();
191       //fPars->SetSeeding(kTRUE);
192       //fPars->SetStreamLevel(0);
193       AliTRDReconstructor reconstructor; reconstructor.SetRecoParam(fPars);
194       // write clusters [cw] = true
195       // track seeding (stand alone tracking) [sa] = true
196       // PID method in reconstruction (NN) [nn] = true
197       // write online tracklets [tw] = false
198       // drift gas [ar] = false
199       reconstructor.SetOption("cw,sa");
200       fTracker = new AliTRDtracker(fGeometryFile);
201       //fTracker = new AliTRDtracker(fGeometryFile);
202     }
203   else
204     {
205       HLTError("Unable to open file. FATAL!");
206       return -1;
207     }
208
209   AliTRDCalibraFillHisto *calibra = AliTRDCalibraFillHisto::Instance();
210   if (calibra == 0)
211     {
212       HLTError("Calibration Histos ::Instance failed");
213       return -1;      
214     }
215   else
216     {
217       calibra->Init2Dhistos();
218     }
219
220   return 0;
221 }
222
223 int AliHLTTRDTrackerComponent::DoDeinit()
224 {
225   // Deinitialization of the component
226
227   delete fField;
228   fField = 0;
229
230   delete fTracker;
231   fTracker = 0;
232   
233   if (fGeometryFile)
234     {
235       fGeometryFile->Close();
236       delete fGeometryFile;
237       fGeometryFile = 0;
238     }
239
240   AliTRDCalibraFillHisto *calibra = AliTRDCalibraFillHisto::Instance();
241   if (calibra)
242     {
243       // should not write in here!
244       calibra->Write2d();
245       calibra->Destroy();
246     }
247
248   return 0;
249 }
250
251 int AliHLTTRDTrackerComponent::DoEvent( const AliHLTComponentEventData & /*evtData*/,
252                                         AliHLTComponentTriggerData & /*trigData*/ )
253 {
254   // Process an event
255   
256   HLTInfo("Output percentage set to %lu %%", fOutputPercentage );
257   HLTInfo("NofBlocks %lu", GetNumberOfInputBlocks() );
258
259   AliHLTUInt32_t dBlockSpecification = 0;
260
261   //implement a usage of the following
262   //   AliHLTUInt32_t triggerDataStructSize = trigData.fStructSize;
263   //   AliHLTUInt32_t triggerDataSize = trigData.fDataSize;
264   //   void *triggerData = trigData.fData;
265   //HLTDebug("Struct size %d Data size %d Data location 0x%x", trigData.fStructSize, trigData.fDataSize, (UInt_t*)trigData.fData);
266
267   AliHLTComponentBlockData *dblock = (AliHLTComponentBlockData *)GetFirstInputBlock( AliHLTTRDDefinitions::fgkClusterDataType );
268   if (dblock != 0)
269     {
270       dBlockSpecification = dblock->fSpecification;
271     }
272   else
273     {
274       HLTWarning("First Input Block not found! 0x%x", dblock);
275       return -1;
276     }
277
278   int ibForce = 0;
279   TObject *tobjin = (TObject *)GetFirstInputObject( AliHLTTRDDefinitions::fgkClusterDataType, "TTree", ibForce);
280   HLTInfo("Pointer = 0x%x", tobjin);
281
282   TTree *clusterTree = (TTree*)tobjin;
283   if (!clusterTree)
284     {
285       HLTWarning("First Input Block not a tree! 0x%x", tobjin);
286       return -1;
287     }
288
289   HLTInfo("Pointer = 0x%x Name = %s", clusterTree, clusterTree->GetName());
290
291   while (tobjin != 0)
292     {
293       if (clusterTree)
294         {
295           HLTInfo("Pointer = 0x%x Name = %s", clusterTree, clusterTree->GetName());
296           Int_t iNentries = clusterTree->GetEntries();
297           HLTInfo("N of tree entries = %d", iNentries);
298           fTracker->LoadClusters(clusterTree);
299         }
300       else
301         {
302           HLTError("Tree Pointer = 0x%x", clusterTree);
303         }
304
305       tobjin = (TObject *)GetNextInputObject( ibForce );
306       HLTInfo("Pointer = 0x%x", tobjin);
307       clusterTree = (TTree*)tobjin;
308     }
309
310   fTracker->SetAddTRDseeds();
311
312   AliESDfriend *esdFriend = new AliESDfriend();
313
314   AliESDEvent *esd = new AliESDEvent();
315   esd->CreateStdContent();
316   fTracker->PropagateBack(esd);
317   fTracker->RefitInward(esd);
318   fTracker->Clusters2Tracks(esd);
319
320   esd->GetESDfriend(esdFriend);
321   //here transport the esd tracks further
322
323   Int_t nTracks = esd->GetNumberOfTracks();
324   Int_t nTRDTracks = esd->GetNumberOfTrdTracks();
325   HLTInfo( "Number of tracks %d Number of TRD tracks %d", nTracks, nTRDTracks);
326
327
328   for (Int_t it = 0; it < nTracks; it++)
329     {
330       AliESDtrack* track = esd->GetTrack(it);
331       HLTInfo("Track %d 0x%x Pt %1.2f", it, track, track->Pt());
332       PushBack(track, AliHLTTRDDefinitions::fgkTRDSATracksDataType, ++dBlockSpecification);
333     }
334
335   delete esd;
336   delete esdFriend;
337
338   delete clusterTree;
339
340   return 0;
341 }