Removed cout message
[u/mrichter/AliRoot.git] / T0 / AliT0Preprocessor.cxx
1 /**************************************************************************
2  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
3  *                                                                        *
4  * Author: The ALICE Off-line Project.                                    *
5  * Contributors are mentioned in the code where appropriate.              *
6  *                                                                        *
7  * Permission to use, copy, modify and distribute this software and its   *
8  * documentation strictly for non-commercial purposes is hereby granted   *
9  * without fee, provided that the above copyright notice appears in all   *
10  * copies and that both the copyright notice and this permission notice   *
11  * appear in the supporting documentation. The authors make no claims     *
12  * about the suitability of this software for any purpose. It is          *
13  * provided "as is" without express or implied warranty.                  *
14  **************************************************************************/
15
16 /*
17 $Log: AliT0Preprocessor.cxx,v $
18 Revision 1.8  2007/12/07 15:22:51  alla
19 bug fixed by Alberto
20  
21 Revision 1.7  2007/12/06 16:35:24  alla
22 new bugs fixed by Tomek
23
24 Revision 1.5  2007/11/23 19:28:52  alla
25 bug fixed
26
27 Version 2.1  2007/11/21 
28 Preprocessor storing data to OCDB (T.Malkiewicz)
29
30 Version 1.1  2006/10   
31 Preliminary test version (T.Malkiewicz)
32 */   
33 // T0 preprocessor:
34 // 1) takes data from DCS and passes it to the class AliTOFDataDCS 
35 // for processing and writes the result to the Reference DB.
36 // 2) takes data form DAQ (both from Laser Calibration and Physics runs), 
37 // processes it, and stores either to OCDB or to Reference DB.
38
39
40 #include "AliT0Preprocessor.h"
41 #include "AliT0DataDCS.h"
42 #include "AliT0CalibWalk.h"
43 #include "AliT0CalibTimeEq.h"
44
45 #include "AliCDBMetaData.h"
46 #include "AliDCSValue.h"
47 #include "AliCDBEntry.h"
48 #include "AliLog.h"
49
50 #include <TTimeStamp.h>
51 #include <TFile.h>
52 #include <TObjString.h>
53 #include <TNamed.h>
54 #include "AliT0Dqclass.h"
55 #include "TClass.h"
56
57 // #include "iostream.h"
58
59 ClassImp(AliT0Preprocessor)
60
61 //____________________________________________________
62 AliT0Preprocessor::AliT0Preprocessor(AliShuttleInterface* shuttle) : 
63   AliPreprocessor("T00", shuttle), 
64   fData(0)
65 {
66   //constructor
67   AddRunType("PHYSICS");
68   AddRunType("STANDALONE");
69   //  AddRunType("LASER");
70 }
71 //____________________________________________________
72
73 AliT0Preprocessor::~AliT0Preprocessor()
74 {
75   //destructor
76   delete fData;
77   fData = 0;
78 }
79 //____________________________________________________
80
81 void AliT0Preprocessor::Initialize(Int_t run, UInt_t startTime, UInt_t endTime)
82 {
83   // Creates AliT0DataDCS object
84   AliPreprocessor::Initialize(run, startTime, endTime);
85   AliInfo(Form("\n\tRun %d \n\tStartTime %s \n\tEndTime %s", run, TTimeStamp(startTime).AsString(), TTimeStamp(endTime).AsString()));
86   fData = new AliT0DataDCS(fRun, fStartTime, fEndTime, GetStartTimeDCSQuery(), GetEndTimeDCSQuery());
87 }
88 //____________________________________________________
89
90 Bool_t AliT0Preprocessor::ProcessDCS(){
91         // Check whether DCS should be processed or not...
92         TString runType = GetRunType();
93         Log(Form("ProcessDCS - RunType: %s",runType.Data()));
94
95         if((runType == "STANDALONE")||
96            (runType == "PHYSICS")){
97            //      (runType == "LASER")){
98           return kFALSE;
99           //    return kTRUE;
100         }else{
101         return kFALSE;
102         }
103 }
104 //____________________________________________________
105
106 UInt_t AliT0Preprocessor::ProcessDCSDataPoints(TMap* dcsAliasMap){
107         // Fills data into AliT0DataDCS object
108         Log("Processing DCS DP");
109         Bool_t resultDCSMap=kFALSE;
110         Bool_t resultDCSStore=kFALSE;
111
112         if(!dcsAliasMap)
113         {
114           Log("No DCS input data");
115           return 1;
116         }
117         else
118         {
119           resultDCSMap=fData->ProcessData(*dcsAliasMap);
120           if(!resultDCSMap)
121           {
122             Log("Error when processing DCS data");
123             return 2;// return error Code for processed DCS data not stored
124           }
125           else
126           {
127             AliCDBMetaData metaDataDCS;
128             metaDataDCS.SetBeamPeriod(0);
129             metaDataDCS.SetResponsible("Tomasz Malkiewicz");
130             metaDataDCS.SetComment("This preprocessor fills an AliTODataDCS object.");
131             AliInfo("Storing DCS Data");
132             resultDCSStore = StoreReferenceData("Calib","DCSData",fData, &metaDataDCS);
133             if (!resultDCSStore)
134             {
135               Log("Some problems occurred while storing DCS data results in ReferenceDB");
136               return 2;// return error Code for processed DCS data not stored
137             }
138           }
139         }
140         return 0;
141 }
142 //____________________________________________________
143 /*
144 UInt_t AliT0Preprocessor::ProcessLaser(){
145         // Processing data from DAQ Standalone run
146   Log("Processing Laser calibration - Walk Correction");
147   
148   //Retrieve the last T0 calibration object
149
150   Float_t parqtcold[24][2], parledold[24][2],parqtcnew[24][2], parlednew[24][2] , goodled[24][2], goodqtc[24][2];
151
152   //  std::cout<<"sizeof "<<sizeof(parqtcold)<<std::endl;
153   memset(parqtcold, 0, sizeof(parqtcold));
154   memset(parqtcnew, 0, sizeof(parqtcnew));
155   memset(parledold, 0, sizeof(parledold));
156   memset(parlednew, 0, sizeof(parlednew));
157   Int_t iStore=0;
158   Bool_t clbold = true;
159
160   AliT0CalibWalk* clb=0;
161   AliCDBEntry* entryCalib = GetFromOCDB("Calib", "Slewing_Walk");
162   if(!entryCalib)
163     Log(Form("Cannot find any AliCDBEntry for [Calib, SlewingWalk]!"));
164   else {
165     clb =dynamic_cast<AliT0CalibWalk*>(entryCalib->GetObject());
166     for(Int_t i=0; i<24; i++)
167       {
168         for(Int_t ipar=0; ipar<2; ipar++)
169           {
170             //    std::cout<<"parqtcold "<<parqtcold[i][ipar]<<std::endl;
171             parqtcold[i][ipar] = clb->GetQTCpar(i,ipar);
172             parledold[i][ipar] = clb->GetLEDpar(i, ipar);
173             goodqtc[i][ipar] = 999;
174             goodled[i][ipar] = 999;
175             //      cout<<" old "<<i<<" "<<ipar<<" qtc "<< parqtcold[i][ipar]<<" led "<<parledold[i][ipar]<<endl;
176           }
177       }
178   }
179
180
181     Bool_t resultLaser=kFALSE;
182     //processing DAQ
183     TList* list = GetFileSources(kDAQ, "LASER");
184     if (list)
185       {
186         TIter iter(list);
187         TObjString *source;
188         while ((source = dynamic_cast<TObjString *> (iter.Next())))
189           {
190             const char *laserFile = GetFile(kDAQ, "LASER", source->GetName());
191             if (laserFile)
192               {
193                 Log(Form("File with Id LASER found in source %s!", source->GetName()));
194                 AliT0CalibWalk *laser = new AliT0CalibWalk();
195                 laser->MakeWalkCorrGraph(laserFile);
196                 //check difference with what was before
197                 if(laser && clb ){
198                   iStore = 1;                           
199                   for(Int_t i=0; i<24; i++)
200                     {
201                       for(Int_t ifit=0; ifit<2; ifit++)
202                         {
203                           parqtcnew[i][ifit] = laser->GetQTCpar(i,ifit);
204                           if( parqtcold[i][ifit] != 0 && parqtcnew[i][ifit] !=0) 
205                             {
206                               goodqtc[i][ifit] = 
207                                 (parqtcnew[i][ifit] - parqtcold[i][ifit])/parqtcold[i][ifit];
208                               //                              cout<<"qtc "<<i<<" "<<ifit<<" "<< goodqtc[i][ifit]<<endl;
209                             }
210                           parlednew[i][ifit] = laser->GetLEDpar(i,ifit);
211                           if(parledold[i][ifit] != 0 && parlednew[i][ifit]!= 0 ) 
212                             {
213                               goodled[i][ifit]= 
214                                 (parlednew[i][ifit] - parledold[i][ifit])/parledold[i][ifit];   
215                               //                              cout<<"led "<<i<<" "<<ifit<<" "<< goodled[i][ifit]<<endl;
216                             }                   
217                           if(TMath::Abs(goodqtc[i][ifit])>0.1 || 
218                              TMath::Abs(goodled[i][ifit])>0.1) 
219                             iStore = 0;
220                         }
221                     }
222                 }
223
224                 AliCDBMetaData metaData;
225                 metaData.SetBeamPeriod(0);
226                 metaData.SetResponsible("Tomek&Michal");
227                 metaData.SetComment("Walk correction from laser runs.");
228                 if( iStore>0)
229                   resultLaser=Store("Calib","Slewing_Walk", laser, &metaData, 0, 1);
230                 delete laser;
231                 Log(Form("resultLaser = %d",resultLaser));
232               }
233               else
234               {
235                 Log(Form("Could not find file with Id LASER in source %s!", source->GetName()));
236                 return 1;
237               }
238             }
239             if (!resultLaser)
240             {
241               Log("No Laser Data stored");
242               return 3;//return error code for failure in storing Laser Data
243             }
244           } else {
245                 Log("No sources found for id LASER!");
246                 return 1;
247           }
248         return 0;
249 }
250 */
251 //____________________________________________________
252
253 UInt_t AliT0Preprocessor::ProcessPhysics(){
254         //Processing data from DAQ Physics run
255         Log("Processing Physics");
256
257         Bool_t resultOnline=kFALSE; 
258         //processing DAQ
259         TList* listPhys = GetFileSources(kDAQ, "PHYSICS");
260         if (listPhys)
261           {
262             TIter iter(listPhys);
263             TObjString *sourcePhys;
264             while ((sourcePhys = dynamic_cast<TObjString *> (iter.Next())))
265             {
266               const char *filePhys = GetFile(kDAQ, "PHYSICS", sourcePhys->GetName());
267               if (filePhys)
268               {
269                 AliT0CalibTimeEq *online = new AliT0CalibTimeEq();
270                 online->Reset();
271                 online->ComputeOnlineParams(filePhys);
272                 AliCDBMetaData metaData;
273                 metaData.SetBeamPeriod(0);
274                 metaData.SetResponsible("Tomek&Michal");
275                 metaData.SetComment("Time equalizing result.");
276                 resultOnline = Store("Calib","TimeDelay", online, &metaData, 0, 1);
277                 Log(Form("resultOnline = %d",resultOnline));
278                 delete online;
279               }
280                 else
281               {
282                 Log(Form("Could not find file with Id PHYSICS in source %s!", sourcePhys->GetName()));
283                 return 1;
284               }
285               
286             }
287             if (!resultOnline)
288             {
289               Log("No Data stored");
290               return 4;//return error code for failure in storing OCDB Data
291             }
292           } else {
293                 Log("No sources found for id PHYSICS!");
294                 return 1;
295           }
296         return 0;
297 }
298 //____________________________________________________
299
300 UInt_t AliT0Preprocessor::Process(TMap* dcsAliasMap )
301 {
302   // T0 preprocessor return codes:
303   // return=0 : all ok
304   // return=1 : no DCS input data 
305   // return=2 : failed to store DCS data
306   // return=3 : no Laser data (Walk correction)
307   // return=4 : failed to store OCDB time equalized data
308   // return=5 : no DAQ input for OCDB
309   // return=6 : failed to retrieve DAQ data from OCDB
310   // return=7 : failed to store T0 OCDB data
311         Bool_t dcsDP = ProcessDCS();
312         Log(Form("dcsDP = %d",dcsDP));  
313         TString runType = GetRunType();
314         Log(Form("RunType: %s",runType.Data()));
315         //processing
316         if(runType == "STANDALONE"){
317           if(dcsDP==1){
318             Int_t iresultDCS = ProcessDCSDataPoints(dcsAliasMap);
319             return iresultDCS;
320           }
321         }
322         /*if(runType == "LASER"){
323           Int_t iresultLaser = ProcessLaser();
324           if(dcsDP==1){
325             Int_t iresultDCS = ProcessDCSDataPoints(dcsAliasMap);
326             return iresultDCS;
327           }
328           Log(Form("iresultLaser = %d",iresultLaser));
329           return iresultLaser;
330         }
331         */
332         else if(runType == "PHYSICS"){
333           Int_t iresultPhysics = ProcessPhysics();
334          //      Int_t iresultCosmic = ProcessCosmic();
335           if(dcsDP==1){
336             Int_t iresultDCS = ProcessDCSDataPoints(dcsAliasMap);
337             return iresultDCS;
338           }
339           Log(Form("iresultPhysics = %d",iresultPhysics));
340           return iresultPhysics; 
341           //            Log(Form("iresultPhysics =iresultCosmic %d",iresultCosmic));
342           //    return iresultCosmic; 
343         }       
344         
345         return 0;
346 }