Kelly:
[u/mrichter/AliRoot.git] / HLT / TPCLib / AliHLTTPCNoiseMapComponent.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   AliHLTTPCNoiseMapComponent.cxx
20     @author Kalliopi Kanaki
21     @date   
22     @brief  The TPC Noise Map component
23 */
24
25 #if __GNUC__>= 3
26 using namespace std;
27 #endif
28
29 #include "AliHLTTPCNoiseMapComponent.h"
30 #include "AliHLTTPCDigitReaderDecoder.h"
31 #include "AliHLTTPCTransform.h"
32 #include "AliHLTTPCDefinitions.h"
33
34 #include "AliCDBEntry.h"
35 #include "AliCDBManager.h"
36 #include "AliCDBStorage.h"
37 #include "AliHLTTPCNoiseMap.h"
38
39 #include "AliTPCCalPad.h"
40 #include "AliTPCROC.h"
41 #include "AliTPCCalROC.h"
42
43 #include <cstdlib>
44 #include <cerrno>
45 #include "TString.h"
46 #include "TFile.h"
47 #include "TObjArray.h"
48 #include "TObjString.h"
49 #include <sys/time.h>
50 #include "TH2.h"
51 #include "TH3.h"
52
53 ClassImp(AliHLTTPCNoiseMapComponent) //ROOT macro for the implementation of ROOT specific class methods
54
55 AliHLTTPCNoiseMapComponent::AliHLTTPCNoiseMapComponent()
56     :    
57     fSpecification(0),
58     fReadNoiseMap(0),
59     fResetHistograms(0),
60     fInitHist(kTRUE),    
61     fCurrentRow(-99),
62     fHistSignal(NULL),
63     fHistSideAMaxSignal(NULL),
64     fHistSideATotSignal(NULL),
65     fHistSideAPadRMS(NULL),
66     fHistSideCMaxSignal(NULL),
67     fHistSideCTotSignal(NULL),
68     fHistSideCPadRMS(NULL),
69     fHistCDBMap(NULL)
70 {
71   // see header file for class documentation
72   // or
73   // refer to README to build package
74   // or
75   // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
76 }
77
78 AliHLTTPCNoiseMapComponent::~AliHLTTPCNoiseMapComponent() { 
79 // see header file for class documentation
80
81 }
82
83 // Public functions to implement AliHLTComponent's interface.
84 // These functions are required for the registration process
85
86 const char* AliHLTTPCNoiseMapComponent::GetComponentID() { 
87 // see header file for class documentation
88
89   return "TPCNoiseMap";
90 }
91
92 void AliHLTTPCNoiseMapComponent::GetInputDataTypes( vector<AliHLTComponentDataType>& list) { 
93 // see header file for class documentation
94
95   list.clear(); 
96   list.push_back( kAliHLTDataTypeDDLRaw | kAliHLTDataOriginTPC );
97 }
98
99 AliHLTComponentDataType AliHLTTPCNoiseMapComponent::GetOutputDataType() { 
100 // see header file for class documentation
101
102   return kAliHLTDataTypeHistogram;
103 }
104
105 int AliHLTTPCNoiseMapComponent::GetOutputDataTypes(AliHLTComponentDataTypeList& tgtList) { 
106 // see header file for class documentation
107
108   tgtList.clear();
109   tgtList.push_back(kAliHLTDataTypeHistogram);
110   return tgtList.size();
111 }
112
113 void AliHLTTPCNoiseMapComponent::GetOutputDataSize( unsigned long& constBase, double& inputMultiplier ) { 
114 // see header file for class documentation
115
116   constBase=800000;
117   inputMultiplier=0.0;
118 }
119
120 AliHLTComponent* AliHLTTPCNoiseMapComponent::Spawn() { 
121 // see header file for class documentation
122
123   return new AliHLTTPCNoiseMapComponent();
124 }
125         
126 int AliHLTTPCNoiseMapComponent::DoInit( int argc, const char** argv ) { 
127 // see header file for class documentation
128  
129   //Int_t i = 0;
130   //Char_t* cpErr;
131   
132   int iResult=0;
133   
134   TString configuration="";
135   TString argument="";
136   for (int j=0; j<argc && iResult>=0; j++) {
137     
138     argument=argv[j];
139     if (!configuration.IsNull()) configuration+=" ";
140     configuration+=argument;    
141   }
142    
143   if (!configuration.IsNull()) {
144     iResult=Configure(configuration.Data());
145   } else {
146     //    iResult=Reconfigure(NULL, NULL);
147   }
148
149  
150 //   while ( i < argc ) {      
151 //     if (!strcmp( argv[i], "-read-noisemap")) {
152 //         fApplyNoiseMap = strtoul( argv[i+1], &cpErr ,0);
153 //             
154 //     if ( *cpErr ) {
155 //         HLTError("Cannot convert apply-noisemap specifier '%s'.", argv[i+1]);
156 //         return EINVAL;
157 //     }
158 //       i+=2;
159 //       continue;
160 //     }
161 //     
162 //     if (!strcmp( argv[i], "-reset-histograms")) {
163 //         fResetHistograms = strtoul( argv[i+1], &cpErr ,0);
164 //     
165 //     if ( *cpErr ) {
166 //         HLTError("Cannot convert reset-histograms specifier '%s'.", argv[i+1]);
167 //         return EINVAL;
168 //     }
169 //       i+=2;
170 //       continue;
171 //     }
172 //                    
173 //     Logging(kHLTLogError, "HLT::TPCNoiseMap::DoInit", "Unknown Option", "Unknown option '%s'", argv[i] );
174 //     return EINVAL;
175 // 
176 //   } // end while
177   
178   if(fReadNoiseMap){
179      AliHLTTPCNoiseMap *nm = AliHLTTPCNoiseMap::Instance();
180      if(!nm) { 
181          HLTWarning("AliHLTTPCNoiseMap instance not existent."); 
182      }
183      else {
184          AliTPCCalPad *noisePad = nm->ReadNoiseMap(GetRunNo());
185          if(noisePad) {
186             fHistCDBMap = noisePad->MakeHisto2D(1);
187             
188          }
189      }
190   }
191
192 //   if(fApplyNoiseMap){
193 //     //TFile *f = TFile::Open("/scratch/noiseComp/Run3398_4000_v0_s72.root");
194 //     TFile *f = TFile::Open("/home/kanaki/noiseComp/Run3398_4000_v0_s72.root");
195 //     AliCDBEntry *pEntry = (AliCDBEntry*)f->Get("AliCDBEntry"); 
196 //     noisePad = (AliTPCCalPad*)pEntry->GetObject();
197 //     //fHistCDBMap = noisePad->MakeHisto2D(1); //side C
198 //   }
199    
200 //   HLTDebug("using AliHLTTPCDigitReaderDecoder");
201 //   pDigitReader = new AliHLTTPCDigitReaderDecoder(); // double-loop
202 //   pDigitReader = new AliHLTTPCDigitReaderPacked();
203   
204   return 0;
205
206 } // end DoInit()
207
208 int AliHLTTPCNoiseMapComponent::DoDeinit() { 
209   // see header file for class documentation  
210
211   if(fHistSideAMaxSignal) delete fHistSideAMaxSignal; fHistSideAMaxSignal = NULL;
212   if(fHistSideATotSignal) delete fHistSideATotSignal; fHistSideATotSignal = NULL;
213   if(fHistSideAPadRMS)    delete fHistSideAPadRMS;    fHistSideAPadRMS    = NULL;
214   
215   if(fHistSideCMaxSignal) delete fHistSideCMaxSignal; fHistSideCMaxSignal = NULL;
216   if(fHistSideCTotSignal) delete fHistSideCTotSignal; fHistSideCTotSignal = NULL;
217   if(fHistSideCPadRMS)    delete fHistSideCPadRMS;    fHistSideCPadRMS    = NULL;
218          
219   return 0;
220 }
221
222 void AliHLTTPCNoiseMapComponent::InitializeHistograms(UInt_t minSlice, UInt_t maxSlice, UInt_t minPartition, UInt_t maxPartition){
223   // see header file for class documentation
224    
225   Char_t name1[50], name2[50], name3[50];
226  
227   if(minSlice<18){
228      sprintf(name1, "fHistSideAMaxSignal_Slice_%.2d%.2d_Partition_%.2d%.2d", minSlice, maxSlice, minPartition, maxPartition);
229      sprintf(name2, "fHistSideATotSignal_Slice_%.2d%.2d_Partition_%.2d%.2d", minSlice, maxSlice, minPartition, maxPartition);
230      sprintf(name3, "fHistSideAPadRMS_Slice_%.2d%.2d_Partition_%.2d%.2d",    minSlice, maxSlice, minPartition, maxPartition);
231      fHistSideAMaxSignal = new TH2F(name1,name1,250,-250,250,250,-250,250);
232      fHistSideATotSignal = new TH2F(name2,name2,250,-250,250,250,-250,250);
233      fHistSideAPadRMS    = new TH2F(name3,name3,250,-250,250,250,-250,250);
234      fHistSideAMaxSignal->SetXTitle("x [cm]");
235      fHistSideATotSignal->SetXTitle("x [cm]");
236      fHistSideAPadRMS->SetXTitle("x [cm]");     
237      fHistSideAMaxSignal->SetYTitle("y [cm]");
238      fHistSideATotSignal->SetYTitle("y [cm]");
239      fHistSideAPadRMS->SetYTitle("y [cm]");     
240
241   } else {
242      sprintf(name1, "fHistSideCMaxSignal_Slice_%.2d%.2d_Partition_%.2d%.2d", minSlice, maxSlice, minPartition, maxPartition);
243      sprintf(name2, "fHistSideCTotSignal_Slice_%.2d%.2d_Partition_%.2d%.2d", minSlice, maxSlice, minPartition, maxPartition);
244      sprintf(name3, "fHistSideCPadRMS_Slice_%.2d%.2d_Partition_%.2d%.2d",    minSlice, maxSlice, minPartition, maxPartition);  
245      fHistSideCMaxSignal = new TH2F(name1,name1,250,-250,250,250,-250,250);
246      fHistSideCTotSignal = new TH2F(name2,name2,250,-250,250,250,-250,250);
247      fHistSideCPadRMS    = new TH2F(name3,name3,250,-250,250,250,-250,250);
248      fHistSideCMaxSignal->SetXTitle("x [cm]");
249      fHistSideCTotSignal->SetXTitle("x [cm]");
250      fHistSideCPadRMS->SetXTitle("x [cm]");     
251      fHistSideCMaxSignal->SetYTitle("y [cm]");
252      fHistSideCTotSignal->SetYTitle("y [cm]");
253      fHistSideCPadRMS->SetYTitle("y [cm]");     
254 }
255     
256   fInitHist=kFALSE;
257   
258 }
259
260 int AliHLTTPCNoiseMapComponent::DoEvent(const AliHLTComponentEventData& /*evtData*/, AliHLTComponentTriggerData& /*trigData*/){
261   // see header file for class documentation
262  
263  
264   if(GetFirstInputBlock( kAliHLTDataTypeSOR ) || GetFirstInputBlock( kAliHLTDataTypeEOR )) return 0;
265   //HLTInfo("--- Entering DoEvent() in TPCNoiseMap ---");
266    
267   const AliHLTComponentBlockData *iter = NULL;
268
269   Float_t xyz[3]; 
270   Int_t thissector, thisrow;
271     
272   /*if(fInitHist==kFALSE) {
273      fHistSideAMaxSignal->Reset();
274      fHistSideCMaxSignal->Reset();  
275   }*/
276
277   
278   for(iter = GetFirstInputBlock(kAliHLTDataTypeDDLRaw|kAliHLTDataOriginTPC); iter != NULL; iter = GetNextInputBlock()){
279       
280 //     HLTInfo("Event 0x%08LX (%Lu) received datatype: %s - required datatype: %s", 
281 //          evtData.fEventID, evtData.fEventID,
282 //          DataType2Text(iter->fDataType).c_str(), 
283 //          DataType2Text(kAliHLTDataTypeDDLRaw | kAliHLTDataOriginTPC).c_str());
284 // 
285 //     if (iter->fDataType == AliHLTTPCDefinitions::fgkDDLPackedRawDataType && GetEventCount()<2){
286 //       HLTWarning("data type %s is depricated, use %s (kAliHLTDataTypeDDLRaw)!", 
287 //               DataType2Text(AliHLTTPCDefinitions::fgkDDLPackedRawDataType).c_str(),
288 //               DataType2Text(kAliHLTDataTypeDDLRaw | kAliHLTDataOriginTPC).c_str());
289 //     }      
290      
291     if (iter->fDataType != (kAliHLTDataTypeDDLRaw | kAliHLTDataOriginTPC)) continue;
292       
293     UInt_t minSlice     = AliHLTTPCDefinitions::GetMinSliceNr(*iter); 
294     UInt_t minPartition = AliHLTTPCDefinitions::GetMinPatchNr(*iter);
295     UInt_t maxSlice     = AliHLTTPCDefinitions::GetMaxSliceNr(*iter); 
296     UInt_t maxPartition = AliHLTTPCDefinitions::GetMaxPatchNr(*iter);
297     
298     if(fInitHist==kTRUE) InitializeHistograms(minSlice, maxSlice, minPartition, maxPartition);    
299     fSpecification = iter->fSpecification;
300      
301     AliHLTTPCDigitReader *pDigitReader = new AliHLTTPCDigitReaderDecoder;
302
303     pDigitReader->InitBlock(iter->fPtr,iter->fSize,minPartition,minSlice);
304     if(!pDigitReader) break;
305                   
306     //  while(pDigitReader->Next()){ 
307
308     Float_t maxSignal     = 0.;
309     Float_t totalSignal   = 0.;
310     Float_t squaredSignal = 0.;
311     Float_t rms = 0.; 
312     
313     while(pDigitReader->NextChannel()) { // pad loop 
314       
315       fCurrentRow  = pDigitReader->GetRow();  
316       fCurrentRow += pDigitReader->GetRowOffset();      
317
318       AliHLTTPCTransform::Slice2Sector(minSlice,fCurrentRow,thissector,thisrow);
319       AliHLTTPCTransform::Raw2Local(xyz,thissector,thisrow,pDigitReader->GetPad(),0);
320             
321       if(minSlice>17) xyz[1] = (-1.0)*xyz[1];
322       
323       AliHLTTPCTransform::Local2Global(xyz,minSlice);
324       // temporarily the transformation Raw2Global will be broken down to 2 steps,
325       // as there is a correction necessary at the y coordinate of the local xyz.
326       
327       //AliHLTTPCTransform::Raw2Global(xyz,thissector,thisrow,pDigitReader->GetPad(),0);
328       // transformation from pad-row coordinates to global ones
329       // time info is not taken into account
330       
331       //       AliTPCCalROC *calRoc = noisePad->GetCalROC(thissector);
332       //       calRoc->GetValue(thisrow,pDigitReader->GetPad());
333       
334       while(pDigitReader->NextBunch()) {
335     
336         const UInt_t *bunchData = pDigitReader->GetSignals();
337         //Int_t time = pDigitReader->GetTime();
338      
339         for(Int_t i=0;i<pDigitReader->GetBunchSize();i++){
340           
341           if((Float_t)(bunchData[i])>maxSignal){ maxSignal = (Float_t)(bunchData[i]); }
342           totalSignal   += (Float_t)bunchData[i];
343           squaredSignal += (Float_t)bunchData[i]*(Float_t)bunchData[i];
344           //fHistSignal->Fill(time+i, bunchData[i]);
345         } // end for loop
346
347         rms = TMath::Sqrt(squaredSignal/pDigitReader->GetBunchSize());
348             
349       } // end of inner while loop           
350      
351      
352       if(minSlice<18){
353         if(maxSignal>0)   fHistSideAMaxSignal->Fill(xyz[0],xyz[1],maxSignal);     
354         if(totalSignal>0) fHistSideATotSignal->Fill(xyz[0],xyz[1],totalSignal);     
355         if(rms>0)         fHistSideAPadRMS->Fill(xyz[0],xyz[1],rms);
356       } else if(minSlice>17){
357         if(maxSignal>0)   fHistSideCMaxSignal->Fill(xyz[0],xyz[1],maxSignal);
358         if(totalSignal>0) fHistSideCTotSignal->Fill(xyz[0],xyz[1],totalSignal); 
359         if(rms>0)         fHistSideCPadRMS->Fill(xyz[0],xyz[1],rms);
360       } else continue;
361       
362       maxSignal     = 0.;
363       totalSignal   = 0.;
364       squaredSignal = 0.;
365       rms = 0.; 
366     } // end of while loop over pads
367     
368     pDigitReader->Reset();
369     delete pDigitReader;
370   } // end of for loop over data blocks
371   
372   //HLTImportant("fHistSideAMaxSignal entries at the end of event: %d", fHistSideAMaxSignal->GetEntries());
373   
374   if(fResetHistograms) ResetHistograms(); fResetHistograms = kFALSE;
375   MakeHistosPublic();
376  
377   return 0;
378 } // end DoEvent()
379
380
381 void AliHLTTPCNoiseMapComponent::MakeHistosPublic() {
382 // see header file for class documentation
383  
384 //   TFile *outputfile = new TFile("test.root","RECREATE");
385 //   fHistSignal->Write();
386 //   outputfile->Save();
387 //   outputfile->Close();
388
389   TObjArray histos;
390   histos.Add(fHistSideAMaxSignal);
391   histos.Add(fHistSideATotSignal);
392   histos.Add(fHistSideAPadRMS);
393   
394   histos.Add(fHistSideCMaxSignal);
395   histos.Add(fHistSideCTotSignal);
396   histos.Add(fHistSideCPadRMS);
397   
398   histos.Add(fHistCDBMap);
399   //histos.Add(fHistSignal);
400   
401   TIter iterator(&histos);
402   while(TObject *pObj=iterator.Next()){ PushBack(pObj, kAliHLTDataTypeHistogram|kAliHLTDataOriginTPC, fSpecification); }
403     
404   //PushBack( (TObject*) &histos, kAliHLTDataTypeHistogram, fSpecification);    
405 }
406
407 void AliHLTTPCNoiseMapComponent::ResetHistograms(){
408 // see header file for class documentation
409
410   if(fHistSideAMaxSignal) fHistSideAMaxSignal->Reset();
411   if(fHistSideATotSignal) fHistSideATotSignal->Reset();
412   if(fHistSideAPadRMS)    fHistSideAPadRMS->Reset();
413  
414   if(fHistSideCMaxSignal) fHistSideCMaxSignal->Reset();
415   if(fHistSideCTotSignal) fHistSideCTotSignal->Reset();
416   if(fHistSideCPadRMS)    fHistSideCPadRMS->Reset();
417 }
418
419 int AliHLTTPCNoiseMapComponent::Configure(const char* arguments) { 
420 // see header file for class documentation
421   
422   int iResult=0;
423   if (!arguments) return iResult;
424   HLTInfo("parsing configuration string \'%s\'", arguments);
425
426   TString allArgs=arguments;
427   TString argument;
428   int bMissingParam=0;
429
430   TObjArray* pTokens=allArgs.Tokenize(" ");
431   if (pTokens) {
432     for (int i=0; i<pTokens->GetEntries() && iResult>=0; i++) {
433       argument=((TObjString*)pTokens->At(i))->GetString();
434       if (argument.IsNull()) continue;
435      
436       if (argument.CompareTo("-read-noisemap")==0) {
437         //if ((bMissingParam=(++i>=pTokens->GetEntries()))) break;
438         fReadNoiseMap = kTRUE;
439         HLTInfo("got \'-read-noisemap\': %s", ((TObjString*)pTokens->At(i))->GetString().Data());
440         
441       } 
442       else if(argument.CompareTo("-reset-histograms")==0){
443         //if ((bMissingParam=(++i>=pTokens->GetEntries()))) break;
444         fResetHistograms = kTRUE;
445         HLTInfo("got \'-reset-histograms\': %s", ((TObjString*)pTokens->At(i))->GetString().Data());    
446       } 
447       else {
448         HLTError("unknown argument %s", argument.Data());
449         iResult=-EINVAL;
450         break;
451       }
452     } // end for
453   
454     delete pTokens;
455   
456   } // end if pTokens
457   
458   if (bMissingParam) {
459     HLTError("missing parameter for argument %s", argument.Data());
460     iResult=-EINVAL;
461   }
462   return iResult;  
463 }
464
465 int AliHLTTPCNoiseMapComponent::Reconfigure(const char* cdbEntry, const char* chainId) { 
466 // see header file for class documentation
467   
468   int iResult = 0;
469   const char* path = "HLT/ConfigTPC/TPCNoiseMapComponent";
470   const char* defaultNotify = "";
471   if(cdbEntry){
472       path          = cdbEntry;
473       defaultNotify = "(manual operator entry)";
474   }
475   
476   if(path){          
477      HLTInfo("reconfigure from entry %s%s, chain id %s", path, defaultNotify,(chainId!=NULL && chainId[0]!=0)?chainId:"<none>" );
478      
479      AliCDBPath argumentPath(path);
480      AliCDBStorage *stor = AliCDBManager::Instance()->GetDefaultStorage();
481         
482      if(stor){
483         Int_t version    = stor->GetLatestVersion(path, GetRunNo());
484         Int_t subVersion = stor->GetLatestSubVersion(path, GetRunNo(), version);
485         AliCDBEntry *pEntry = stor->Get(argumentPath,GetRunNo(), version, subVersion);
486
487         if(pEntry){
488             TObjString* pString = dynamic_cast<TObjString*>(pEntry->GetObject());
489             if(pString){
490                HLTInfo("received configuration object string: \'%s\'", pString->GetString().Data());
491                iResult = Configure(pString->GetString().Data());
492             } // if pString is valid
493             else {
494                HLTError("configuration object \"%s\" has wrong type, required TObjString", path);
495             }
496         } // if pEntry is valid
497         else {
498            HLTError("cannot fetch object \"%s\" from CDB", path);
499         }
500      } // end if stor is valid
501   } // end if path is valid
502   
503   return iResult;
504
505
506 }