splitting the functionality of the TRD calibration components, old component kept...
[u/mrichter/AliRoot.git] / HLT / TRD / AliHLTTRDCalibFitComponent.cxx
1 // $Id: AliHLTTRDCalibFitComponent.cxx 40282 2010-04-09 13:29:10Z richterm $
2
3 /**************************************************************************
4  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
5  *                                                                        *
6  * Authors:                                                               *
7  *          for The ALICE HLT Project.                                    *
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   AliHLTTRDCalibFitComponent.cxx
19 //  @author Theodor Rascanu
20 //  @date   25.04.2010
21 //  @brief  A TRDCalibration fitting component for the HLT. 
22 // 
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 #include "TH2I.h"
32 #include "TH2.h"
33 #include "TProfile2D.h"
34
35 #include "AliHLTReadoutList.h"
36
37 #include "AliHLTTRDCalibFitComponent.h"
38 #include "AliHLTTRDDefinitions.h"
39 #include "AliHLTTRDUtils.h"
40
41 #include "AliRawReaderMemory.h"
42
43 #include "AliTRDCalPad.h"
44 #include "AliTRDCalDet.h"
45
46 #include "AliTRDCalibraFillHisto.h"
47 #include "AliTRDtrackV1.h"
48
49 #include "AliTRDCalibraFit.h"
50 #include "AliTRDCalibraMode.h"
51 #include "AliTRDCalibraVector.h"
52 #include "AliTRDCalibraVdriftLinearFit.h"
53 #include "AliTRDReconstructor.h"
54 #include "AliTRDrecoParam.h"
55
56 #include <cstdlib>
57 #include <cerrno>
58 #include <string>
59
60 ClassImp(AliHLTTRDCalibFitComponent);
61
62 AliHLTTRDCalibFitComponent::AliHLTTRDCalibFitComponent()
63   : AliHLTCalibrationProcessor(),
64     fOutputSize(500000),
65     fOutArray(NULL),
66     fTempArray(NULL),
67     fAfterRunArray(NULL)
68 {
69   // Default constructor
70 }
71
72 AliHLTTRDCalibFitComponent::~AliHLTTRDCalibFitComponent()
73 {
74   // Destructor
75 }
76
77 const char* AliHLTTRDCalibFitComponent::GetComponentID()
78 {
79   // Return the component ID const char *
80   return "TRDCalibFit"; // The ID of this component
81 }
82
83 void AliHLTTRDCalibFitComponent::GetInputDataTypes( vector<AliHLTComponentDataType>& list)
84 {
85   // Get the list of input data
86   list.clear(); // We do not have any requirements for our input data type(s).
87   list.push_back(AliHLTTRDDefinitions::fgkCalibrationDataType);
88 }
89
90 AliHLTComponentDataType AliHLTTRDCalibFitComponent::GetOutputDataType()
91 {
92   // Get the output data type
93   return kAliHLTMultipleDataType;
94   //  return AliHLTTRDDefinitions::fgkCalibrationDataType;
95  
96 }
97
98 int AliHLTTRDCalibFitComponent::GetOutputDataTypes(AliHLTComponentDataTypeList& tgtList)
99 {
100   // Get the output data type
101   tgtList.clear();
102   tgtList.push_back(AliHLTTRDDefinitions::fgkCalibrationDataType);
103   tgtList.push_back(AliHLTTRDDefinitions::fgkEORCalibrationDataType);
104   return tgtList.size();
105 }
106
107 void AliHLTTRDCalibFitComponent::GetOutputDataSize( unsigned long& constBase, double& inputMultiplier )
108 {
109   // Get the output data size
110   constBase = fOutputSize;
111   inputMultiplier = 0;
112 }
113
114 AliHLTComponent* AliHLTTRDCalibFitComponent::Spawn()
115 {
116   // Spawn function, return new instance of this class
117   return new AliHLTTRDCalibFitComponent;
118 };
119
120 Int_t AliHLTTRDCalibFitComponent::InitCalibration()
121 {
122   for(int i=0; i<18; i++)
123     fIncSM[i]=kFALSE;
124
125   fOutArray = new TObjArray(4);
126   fAfterRunArray=new TObjArray(5);
127
128   return 0;
129 }
130
131 Int_t AliHLTTRDCalibFitComponent::DeinitCalibration()
132 {
133   
134   // Deinitialization of the component
135   
136   HLTDebug("DeinitCalibration");
137   //fOutArray->Delete();
138   if(fTempArray){
139     delete fTempArray; fTempArray=0;
140   }
141   delete fOutArray; fOutArray=0;
142   fAfterRunArray->Delete();
143   delete fAfterRunArray; fAfterRunArray=0;
144   return 0;
145 }
146
147 Int_t AliHLTTRDCalibFitComponent::ProcessCalibration(const AliHLTComponent_EventData& /*evtData*/,
148                                                         const AliHLTComponent_BlockData* /*blocks*/,
149                                                         AliHLTComponent_TriggerData& /*trigData*/,
150                                                         AliHLTUInt8_t* /*outputPtr*/,
151                                                         AliHLTUInt32_t& /*size*/,
152                                                         vector<AliHLTComponent_BlockData>& /*outputBlocks*/)
153 {
154   // Process an event
155
156   if(!IsDataEvent())return 0;
157
158   int lastSM = -1;
159
160   for(const TObject* iter = GetFirstInputObject(AliHLTTRDDefinitions::fgkCalibrationDataType);
161       iter != NULL; iter = GetNextInputObject() ) {
162
163     if(!dynamic_cast<const TObjArray*>(iter))
164       continue;
165
166     AliHLTUInt32_t spec = GetSpecification(iter);
167     int SM = AliHLTTRDUtils::GetSM(spec);
168
169     HLTInfo("Got Data from SM %i", SM);
170
171     if(SM!=lastSM){
172       if(fIncSM[SM]){
173         PushBack(fTempArray, AliHLTTRDDefinitions::fgkCalibrationDataType);
174         fOutArray->Delete();
175         delete fOutArray;
176         fOutArray = fTempArray;
177         fTempArray = NULL;
178         for(int i=0; i<18; i++)
179           fIncSM[i]=kFALSE;
180       }
181       lastSM = SM;
182       fIncSM[SM]=kTRUE;
183     }
184
185     if(!fTempArray) fTempArray = (TObjArray*)iter->Clone();
186     else{
187       TObjArray* inArr = (TObjArray*)iter;
188       for(int i = inArr->GetEntriesFast(); i--;){
189         const TH1* histo = dynamic_cast<const TH1*>(inArr->At(i));
190         if(histo){
191           if(fTempArray->At(i)){
192             ((TH1*)fTempArray->At(i))->Add(histo);
193           }else{
194             fTempArray->AddAt(histo->Clone(), i);
195           }
196           continue;
197         }
198         AliTRDCalibraVdriftLinearFit* obj = dynamic_cast<AliTRDCalibraVdriftLinearFit*>(inArr->At(i));
199         if(obj){
200           if(fTempArray->At(i)){
201             ((AliTRDCalibraVdriftLinearFit*)fTempArray->At(i))->Add(obj);
202           }else{
203             fTempArray->AddAt(new AliTRDCalibraVdriftLinearFit(*obj), i);
204           }
205         }
206       }
207     }
208
209   }
210
211   return 0;
212 }
213
214 Int_t AliHLTTRDCalibFitComponent::ShipDataToFXS(const AliHLTComponentEventData& /*evtData*/, AliHLTComponentTriggerData& /*trigData*/)
215 {
216   //fTRDCalibraFillHisto->DestroyDebugStreamer();
217
218   AliHLTReadoutList rdList(AliHLTReadoutList::kTRD);
219
220   EORCalibration();
221   
222   fOutArray->Remove(fOutArray->FindObject("AliTRDCalibraVdriftLinearFit"));
223   //fOutArray->Remove(fOutArray->FindObject("PRF2d"));
224   //fOutArray->Remove(fOutArray->FindObject("PH2d"));
225   //fOutArray->Remove(fOutArray->FindObject("CH2d"));
226
227   if(!(fOutArray->FindObject("CH2d"))) {
228     TH2I * ch2d = new TH2I("CH2d","Nz0Nrphi0",100,0.0,300.0,540,0,540);
229     fOutArray->Add(ch2d);
230   }
231
232   if(!(fOutArray->FindObject("PH2d"))) {
233     TProfile2D * ph2d = new TProfile2D("PH2d","Nz0Nrphi0",30,-0.05,2.95,540,0,540);
234     fOutArray->Add(ph2d);
235   }
236
237   if(!(fOutArray->FindObject("PRF2d"))) {
238     TProfile2D * prf2d = new TProfile2D("PRF2d","Nz0Nrphi0Ngp3",60,-9.0,9.0,540,0,540);
239     fOutArray->Add(prf2d);
240   }
241
242   HLTDebug("Size of the fOutArray is %d\n",fOutArray->GetEntriesFast());
243
244   PushToFXS((TObject*)fOutArray, "TRD", "GAINDRIFTPRF", rdList.Buffer() );
245   //PushToFXS((TObject*)fOutArray->FindObject("CH2d"), "TRD", "GAINDRIFTPRF", rdList.Buffer() );
246
247   return 0;
248 }
249
250 Int_t AliHLTTRDCalibFitComponent::EORCalibration()
251 {
252   //Also Fill histograms for the online display
253   TH2I *hCH2d=(TH2I*)fOutArray->FindObject("CH2d");
254   TProfile2D *hPH2d=(TProfile2D*)fOutArray->FindObject("PH2d");
255   TProfile2D *hPRF2d= (TProfile2D*)fOutArray->FindObject("PRF2d");
256   AliTRDCalibraVdriftLinearFit* hVdriftLinearFit = (AliTRDCalibraVdriftLinearFit*)fOutArray->FindObject("AliTRDCalibraVdriftLinearFit");
257  
258
259   if(!hCH2d || !hPH2d || !hPRF2d || !hVdriftLinearFit) return 0; 
260
261   //Fit
262   AliTRDCalibraFit *calibra = AliTRDCalibraFit::Instance();
263
264   //Gain
265   calibra->SetMinEntries(100);
266   calibra->AnalyseCH(hCH2d);
267   Int_t nbtg = 6*4*18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb0(0))
268     + 6*  18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb2(0));
269   Int_t nbfit       = calibra->GetNumberFit();
270   Int_t nbE         = calibra->GetNumberEnt();
271   TH1F *coefgain = 0x0;
272   // enough statistics
273   //if ((nbtg >                  0) && 
274   //   (nbfit        >= 0.2*nbE)) {
275   // create the cal objects
276   //calibra->PutMeanValueOtherVectorFit(1,kTRUE);
277   TObjArray object           = calibra->GetVectorFit();
278   AliTRDCalDet *objgaindet   = calibra->CreateDetObjectGain(&object,kFALSE);
279   coefgain                   = objgaindet->MakeHisto1DAsFunctionOfDet();
280   //}
281   calibra->ResetVectorFit();
282
283   // vdrift second method
284   calibra->SetMinEntries(100); // If there is less than 100
285   hVdriftLinearFit->FillPEArray();
286   calibra->AnalyseLinearFitters(hVdriftLinearFit);
287   nbtg = 540;
288   nbfit = calibra->GetNumberFit();
289   nbE   = calibra->GetNumberEnt();
290   TH1F *coefdriftsecond = 0x0;
291   // enough statistics
292   //if ((nbtg >                  0) && 
293   // (nbfit        >= 0.1*nbE)) {
294   // create the cal objects
295   //calibra->PutMeanValueOtherVectorFit(1,kTRUE);
296   object  = calibra->GetVectorFit();
297   AliTRDCalDet *objdriftvelocitydetsecond = calibra->CreateDetObjectVdrift(&object,kTRUE);
298   objdriftvelocitydetsecond->SetTitle("secondmethodvdrift");
299   coefdriftsecond  = objdriftvelocitydetsecond->MakeHisto1DAsFunctionOfDet();
300   //}
301   calibra->ResetVectorFit();
302   
303   // vdrift first method
304   calibra->SetMinEntries(100*20); // If there is less than 20000
305   calibra->AnalysePH(hPH2d);
306   nbtg = 6*4*18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb0(1))
307     + 6*  18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb2(1));
308   nbfit        = calibra->GetNumberFit();
309   nbE          = calibra->GetNumberEnt();
310   TH1F *coefdrift = 0x0;
311   TH1F *coeft0 = 0x0;
312   // enough statistics
313   //if ((nbtg >                  0) && 
314   // (nbfit        >= 0.2*nbE)) {
315   // create the cal objects
316   //calibra->PutMeanValueOtherVectorFit(1,kTRUE);
317   //calibra->PutMeanValueOtherVectorFit2(1,kTRUE);
318   object  = calibra->GetVectorFit();
319   AliTRDCalDet *objdriftvelocitydet = calibra->CreateDetObjectVdrift(&object,kTRUE);
320   coefdrift        = objdriftvelocitydet->MakeHisto1DAsFunctionOfDet();
321   object              = calibra->GetVectorFit2();
322   AliTRDCalDet *objtime0det  = calibra->CreateDetObjectT0(&object,kTRUE);
323   coeft0        = objtime0det->MakeHisto1DAsFunctionOfDet();
324   //}
325   calibra->ResetVectorFit();
326            
327
328   //PRF
329   calibra->SetMinEntries(200); 
330   calibra->AnalysePRFMarianFit(hPRF2d);
331   nbtg = 6*4*18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb0(2))
332     + 6*  18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb2(2));
333   nbfit        = calibra->GetNumberFit();
334   nbE          = calibra->GetNumberEnt();
335   TH1F *coefprf = 0x0;
336   // enough statistics
337   //if ((nbtg >                  0) && 
338   //  (nbfit        >= 0.95*nbE)) {
339   // create cal pad objects 
340   object            = calibra->GetVectorFit();
341   TObject *objPRFpad          = calibra->CreatePadObjectPRF(&object);
342   coefprf                     = ((AliTRDCalPad *) objPRFpad)->MakeHisto1D();
343   //}
344   calibra->ResetVectorFit();
345
346
347   coefgain->SetName("coefgain");
348   coefprf->SetName("coefprf");
349   coefdrift->SetName("coefdrift");
350   coefdriftsecond->SetName("coefdriftsecond");
351   coeft0->SetName("coeft0");
352   if(coefgain) fAfterRunArray->Add(coefgain);
353   if(coefprf) fAfterRunArray->Add(coefprf);
354   if(coefdrift) fAfterRunArray->Add(coefdrift);
355   if(coefdriftsecond) fAfterRunArray->Add(coefdriftsecond);
356   if(coeft0) fAfterRunArray->Add(coeft0);
357   
358
359   if(coefgain||coefprf||coefdrift||coeft0||coefdriftsecond) {
360     PushBack(fAfterRunArray, AliHLTTRDDefinitions::fgkEORCalibrationDataType);
361   }
362
363   // TString fileName="/tmp/CalibHistoDump_run";
364   // fileName+=AliCDBManager::Instance()->GetRun();
365   // fileName+=".root";
366   // HLTInfo("Dumping Histogram file to %s",fileName.Data());
367   // TFile* file = TFile::Open(fileName, "RECREATE");
368   // fAfterRunArray->Write();
369   // fOutArray->Write();
370   // file->Close();
371   // HLTInfo("Histogram file dumped");
372
373   return 0;
374 }       
375