d3b8fd2edf3debe8cb0270dd2eb934731762c384
[u/mrichter/AliRoot.git] / HLT / TRD / AliHLTTRDCalibrationComponent.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   AliHLTTRDCalibrationComponent.cxx
20     @author Timm Steinbeck, Matthias Richter
21     @date   
22     @brief  A TRDCalibration processing component for the HLT. */
23
24 #if __GNUC__ >= 3
25 using namespace std;
26 #endif
27
28 #include "TTree.h"
29 #include "TFile.h"
30 #include "TBranch.h"
31
32 #include "AliHLTTRDCalibrationComponent.h"
33 #include "AliHLTTRDDefinitions.h"
34 #include "AliHLTTRDTrack.h"
35
36 #include "AliCDBManager.h"
37 #include "AliTRDclusterizerHLT.h"
38 #include "AliRawReaderMemory.h"
39 #include "AliTRDCalibraFillHisto.h"
40
41 #include <cstdlib>
42 #include <cerrno>
43 #include <string>
44
45 // this is a global object used for automatic component registration, do not use this
46 AliHLTTRDCalibrationComponent gAliHLTTRDCalibrationComponent;
47
48 ClassImp(AliHLTTRDCalibrationComponent);
49    
50 AliHLTTRDCalibrationComponent::AliHLTTRDCalibrationComponent():
51   AliHLTCalibrationProcessor(),
52   fTRDCalibraFillHisto(NULL),
53   fUseHLTTracks(kFALSE),
54   fOutputPercentage(100), // By default we copy to the output exactly what we got as input  
55   fStrorageDBpath("local://$ALICE_ROOT/OCDB"),
56   fCDB(NULL)
57 {
58   // Default constructor
59 }
60
61 AliHLTTRDCalibrationComponent::~AliHLTTRDCalibrationComponent()
62 {
63   // Destructor
64   ;
65 }
66
67 const char* AliHLTTRDCalibrationComponent::GetComponentID()
68 {
69   // Return the component ID const char *
70   return "TRDCalibration"; // The ID of this component
71 }
72
73 void AliHLTTRDCalibrationComponent::GetInputDataTypes( vector<AliHLTComponent_DataType>& list)
74 {
75   // Get the list of input data
76   list.clear(); // We do not have any requirements for our input data type(s).
77   list.push_back( AliHLTTRDDefinitions::fgkTRDSATracksDataType );
78 }
79
80 AliHLTComponent_DataType AliHLTTRDCalibrationComponent::GetOutputDataType()
81 {
82   // Get the output data type
83   return AliHLTTRDDefinitions::fgkCalibrationDataType;
84 }
85
86 void AliHLTTRDCalibrationComponent::GetOutputDataSize( unsigned long& constBase, double& inputMultiplier )
87 {
88   // Get the output data size
89   constBase = 0;
90   inputMultiplier = ((double)fOutputPercentage)/100.0;
91 }
92
93 AliHLTComponent* AliHLTTRDCalibrationComponent::Spawn()
94 {
95   // Spawn function, return new instance of this class
96   return new AliHLTTRDCalibrationComponent;
97 };
98
99 Int_t AliHLTTRDCalibrationComponent::ScanArgument( int argc, const char** argv )
100 {
101   // perform initialization. We check whether our relative output size is specified in the arguments.
102   fOutputPercentage = 100;
103   int i = 0;
104   char* cpErr;
105   while ( i < argc )
106     {
107       HLTDebug("argv[%d] == %s", i, argv[i] );
108       if ( !strcmp( argv[i], "output_percentage" ) )
109         {
110           if ( i+1>=argc )
111             {
112               HLTError("Missing output_percentage parameter");
113               return ENOTSUP;
114             }
115           HLTDebug("argv[%d+1] == %s", i, argv[i+1] );
116           fOutputPercentage = strtoul( argv[i+1], &cpErr, 0 );
117           if ( *cpErr )
118             {
119               HLTError("Cannot convert output_percentage parameter '%s'", argv[i+1] );
120               return EINVAL;
121             }
122           HLTInfo("Output percentage set to %lu %%", fOutputPercentage );
123           i += 2;
124           continue;
125         }
126       else if ( strcmp( argv[i], "-cdb" ) == 0)
127         {
128           if ( i+1 >= argc )
129             {
130               HLTError("Missing -cdb argument");
131               return ENOTSUP;         
132             }
133           fStrorageDBpath = argv[i+1];
134           HLTInfo("DB storage is %s", fStrorageDBpath.c_str() );          
135           i += 2;
136           continue;
137         }  
138       else if ( strcmp( argv[i], "-useHLTTracks" ) == 0){
139         fUseHLTTracks = kTRUE;
140         i++;
141         HLTInfo("Expecting block of AliHLTTracks as input. Using low-level interface");
142       }
143       else{
144         HLTError("Unknown option '%s'", argv[i] );
145         return EINVAL;
146       }
147     }
148   return 0;
149 }
150
151 Int_t AliHLTTRDCalibrationComponent::InitCalibration()
152 {
153   //init the calibration
154   fCDB = AliCDBManager::Instance();
155   if (!fCDB)
156     {
157       HLTError("Could not get CDB instance, fCDB 0x%x", fCDB);
158     }
159   else
160     {
161       fCDB->SetRun(0); // THIS HAS TO BE RETRIEVED !!!
162       fCDB->SetDefaultStorage(fStrorageDBpath.c_str());
163       HLTDebug("fCDB 0x%x", fCDB);
164     }
165   fTRDCalibraFillHisto = AliTRDCalibraFillHisto::Instance();
166   fTRDCalibraFillHisto->SetHisto2d(); // choose to use histograms
167   fTRDCalibraFillHisto->SetCH2dOn();  // choose to calibrate the gain
168   fTRDCalibraFillHisto->SetPH2dOn();  // choose to calibrate the drift velocity
169   fTRDCalibraFillHisto->SetPRF2dOn(); // choose to look at the PRF
170   fTRDCalibraFillHisto->Init2Dhistos(); // initialise the histos
171   return 0;
172 }
173
174 Int_t AliHLTTRDCalibrationComponent::DeinitCalibration()
175 {
176   HLTDebug("DeinitCalibration");
177   
178   // Deinitialization of the component
179
180   if (fCDB)
181     {
182       HLTDebug("destroy fCDB");
183       fCDB->Destroy();
184       fCDB = 0;
185     }
186   return 0;
187 }
188
189 Int_t AliHLTTRDCalibrationComponent::ProcessCalibration(const AliHLTComponent_EventData& evtData,
190                                                         const AliHLTComponent_BlockData* blocks,
191                                                         AliHLTComponent_TriggerData& /*trigData*/,
192                                                         AliHLTUInt8_t* /*outputPtr*/,
193                                                         AliHLTUInt32_t& /*size*/,
194                                                         vector<AliHLTComponent_BlockData>& /*outputBlocks*/)
195 {
196   // Process an event
197   //   Logging( kHLTLogInfo, "HLT::TRDCalibration::ProcessCalibration", "Output percentage set", "Output percentage set to %lu %%", fOutputPercentage );
198   HLTDebug("NofBlocks %lu", evtData.fBlockCnt );
199   // Process an event
200
201   // Loop over all input blocks in the event
202   vector<AliHLTComponent_DataType> expectedDataTypes;
203   GetInputDataTypes(expectedDataTypes);
204   for ( unsigned long iBlock = 0; iBlock < evtData.fBlockCnt; iBlock++ )
205     {
206       const AliHLTComponentBlockData &block = blocks[iBlock];
207       AliHLTComponentDataType inputDataType = block.fDataType;
208       Bool_t correctDataType = kFALSE;
209       
210       for(UInt_t i = 0; i < expectedDataTypes.size(); i++)
211         if( expectedDataTypes.at(i) == inputDataType)
212           correctDataType = kTRUE;
213       if (!correctDataType)
214         {
215           HLTDebug( "Block # %i/%i; Event 0x%08LX (%Lu) Wrong received datatype: %s - Skipping",
216                     iBlock, evtData.fBlockCnt,
217                     evtData.fEventID, evtData.fEventID, 
218                     DataType2Text(inputDataType).c_str());
219           continue;
220         }
221       else 
222         HLTDebug("We get the right data type: Block # %i/%i; Event 0x%08LX (%Lu) Received datatype: %s",
223                     iBlock, evtData.fBlockCnt-1,
224                     evtData.fEventID, evtData.fEventID, 
225                     DataType2Text(inputDataType).c_str());
226
227       TClonesArray* tracksArray = NULL;
228       int ibForce = 0;
229       if (fUseHLTTracks)
230         {
231           tracksArray = new TClonesArray("AliTRDtrackV1");
232           HLTDebug("BLOCK fPtr 0x%x, fOffset %i, fSize %i, fSpec 0x%x, fDataType %s", block.fPtr, block.fOffset, block.fSize, block.fSpecification, DataType2Text(block.fDataType).c_str());
233           ReadTracks(tracksArray, block.fPtr, block.fSize);
234         }
235       else
236         {
237           TObject *objIn = NULL;
238           if (iBlock == 0)
239             objIn = (TObject *)GetFirstInputObject( AliHLTTRDDefinitions::fgkTRDSATracksDataType, "TClonesArray", ibForce);
240           else
241             objIn = (TObject *)GetNextInputObject( ibForce );
242           HLTDebug("1stBLOCK, Pointer = 0x%x", objIn);
243           if (objIn){
244             tracksArray = (TClonesArray* )objIn;
245           }
246         }
247
248       if (tracksArray)
249         {
250           Int_t nbEntries = tracksArray->GetEntries();
251           HLTDebug(" %i TRDtracks in tracksArray", nbEntries);
252           AliTRDtrackV1* trdTrack = 0x0;
253           for (Int_t i = 0; i < nbEntries; i++){
254             HLTDebug("%i/%i: ", i+1, nbEntries);
255             trdTrack = (AliTRDtrackV1*)tracksArray->At(i);
256             trdTrack->Print();
257             fTRDCalibraFillHisto->UpdateHistogramsV1(trdTrack);
258           }
259         }
260       
261
262       TObjArray *outArray = FormOutput();
263       if (outArray){
264         PushBack(outArray, AliHLTTRDDefinitions::fgkCalibrationDataType);
265         delete outArray;
266       }
267       
268     }
269   return 0;
270   
271 }
272
273 /**
274  * Read track to the TClonesArray from the memory 
275  */
276 //============================================================================
277 Int_t AliHLTTRDCalibrationComponent::ReadTracks(TClonesArray *outArray, void* inputPtr, AliHLTUInt32_t size)
278 {
279   AliHLTUInt8_t* iterPtr = (AliHLTUInt8_t* )inputPtr;
280   
281   cout << "\nReading tracks from the Memory\n ============= \n";
282   AliHLTTRDTrack * hltTrack;
283   AliHLTUInt32_t trackSize = 0, curSize = 0;
284   Int_t counter=0;
285   
286   while (curSize < size)
287     {
288       hltTrack = (AliHLTTRDTrack*) iterPtr;
289       HLTDebug("curSize %i, size %i",curSize, size);
290       
291       trackSize = hltTrack->GetSize();
292       HLTDebug("GetSize() %i", trackSize);
293
294       hltTrack->ReadTrackletsFromMemory(iterPtr + sizeof(AliHLTTRDTrack));
295
296       AliTRDtrackV1* curTRDTrack = new((*outArray)[counter]) AliTRDtrackV1();
297       hltTrack->ExportTRDTrack(curTRDTrack);
298       
299       curSize += trackSize; 
300       iterPtr += trackSize;
301       counter++;
302     }
303
304   //CheckTrackArray(outArray);
305   return counter;
306 }
307
308
309 Int_t AliHLTTRDCalibrationComponent::ShipDataToFXS( const AliHLTComponentEventData& /*evtData*/, AliHLTComponentTriggerData& /*trigData*/)
310 {
311 //   //Int_t PushToFXS(TObject* pObject, const char* pDetector, const char* pFileID, const char* pDDLNumber = "");
312 //   //ireturn = PushToFXS(object, "TRD ", "TRDCalib", "1024 ");
313
314   TObjArray *outArray = FormOutput();
315   HLTDebug("Shipping data. Dummy. outputArray: pointer = 0x%x; NEntries = %i;", outArray, outArray->GetEntries());
316   Int_t ireturn = PushToFXS(outArray, "TRD ", "TRDCalib");
317   
318   if (outArray){
319     outArray->Delete();
320     delete outArray;
321   }
322   
323   return ireturn;
324 }
325
326
327 /**
328  * Form output array of histrograms 
329  */
330 //============================================================================
331 TObjArray* AliHLTTRDCalibrationComponent::FormOutput()
332 {
333   TObjArray *outArray=new TObjArray(3);
334
335   // gain histo
336   TH2I *hCH2d = fTRDCalibraFillHisto->GetCH2d();
337   outArray->Add(hCH2d);
338
339   // drift velocity histo
340   TProfile2D *hPH2d = fTRDCalibraFillHisto->GetPH2d();
341   outArray->Add(hPH2d);
342        
343   // PRF histo
344   TProfile2D *hPRF2d = fTRDCalibraFillHisto->GetPRF2d(); 
345   outArray->Add(hPRF2d);
346
347   HLTDebug("GetCH2d = 0x%x; NEntries = %i; size = %i", hCH2d, hCH2d->GetEntries(), sizeof(hCH2d));
348   hCH2d->Print();
349   HLTDebug("GetPH2d = 0x%x; NEntries = %i; size = %i", hPH2d, hPH2d->GetEntries(), sizeof(hPH2d));
350   hPH2d->Print();
351   HLTDebug("GetPRF2d = 0x%x; NEntries = %i; size = %i", hPRF2d, hPRF2d->GetEntries(), sizeof(hPRF2d));
352   hPRF2d->Print();
353   HLTDebug("output Array: pointer = 0x%x; NEntries = %i; size = %i", outArray, outArray->GetEntries(), sizeof(outArray));
354     
355   
356   
357   return outArray;
358   
359 }
360