New calibration object to store the HLT status to be used to define the SDD raw data...
[u/mrichter/AliRoot.git] / ITS / AliITSPreprocessorSDD.cxx
1 /**************************************************************************
2  * Copyright(c) 2007-2009, 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 /* $Id$ */
17
18 ///////////////////////////////////////////////////////////////////
19 //                                                               //
20 // Implementation of the class for SDD preprocessing             //
21 // Origin: E.Crescio, Torino, crescio@to.infn.it                 //
22 //         F.Prino, Torino, prino@to.infn.it                     //
23 //                                                               //
24 ///////////////////////////////////////////////////////////////////
25
26 #include "AliITSPreprocessorSDD.h"
27 #include "AliITSCalibrationSDD.h"
28 #include "AliITSDriftSpeedSDD.h"
29 #include "AliITSDriftSpeedArraySDD.h"
30 #include "AliITSDCSAnalyzerSDD.h"
31 #include "AliITSHLTforSDD.h"
32 #include "AliShuttleInterface.h"
33 #include "AliCDBEntry.h"
34 #include "AliCDBMetaData.h"
35 #include "TObjArray.h"
36 #include "AliLog.h"
37 #include <TObjString.h>
38 #include <TSystem.h>
39 #include <TList.h>
40
41 const TString AliITSPreprocessorSDD::fgkNameHistoPedestals = "hpedestal";
42 const TString AliITSPreprocessorSDD::fgkNameHistoNoise = "hnoise";
43 ClassImp(AliITSPreprocessorSDD)
44
45 //______________________________________________________________________
46 AliITSPreprocessorSDD::AliITSPreprocessorSDD( AliShuttleInterface* shuttle):
47     AliPreprocessor("SDD", shuttle)
48 {
49   // constructor
50   AddRunType("PULSER");
51   AddRunType("INJECTOR");
52   AddRunType("PHYSICS"); 
53 }
54
55 //______________________________________________________________________
56 UInt_t AliITSPreprocessorSDD::Process(TMap* dcsAliasMap){
57
58
59   // Get DDL map from OCDB
60   AliCDBEntry* entry = GetFromOCDB("Calib", "DDLMapSDD");
61   if(!entry){
62     Log("DDL map file not found in OCDB.");  
63     return 2;
64   }
65   AliITSDDLModuleMapSDD* ddlmap = (AliITSDDLModuleMapSDD*)entry->GetObject();
66   if(!ddlmap){ 
67     Log("AliITSDDLModuleMapSDD object not in file.");
68     return 2;
69   }
70   ddlmap->PrintDDLMap();
71
72   //preprocessing
73   TString runType = GetRunType();
74   Int_t retcode=0;
75
76   if (runType == "PULSER"){
77     Log("Process FXS files from PULSER RUN");
78     retcode=ProcessPulser(ddlmap);
79   }else if(runType== "INJECTOR"){
80     Log("Process FXS files from INJECTOR RUN");
81     retcode=ProcessInjector(ddlmap);
82   }else if(runType== "PHYSICS"){
83     retcode=ProcessPhysics();
84   }
85   if(retcode!=0) return retcode;
86
87   Log("Process DCS data");
88   Bool_t retcodedcs =ProcessDCSDataPoints(dcsAliasMap);
89   if(retcodedcs) return 0; 
90   else return 1;           
91
92 }
93 //______________________________________________________________________
94 UInt_t AliITSPreprocessorSDD::ProcessPhysics(){
95   // Get the HLT status for the PHYSICS run 
96   // needeed to define the raw data format  
97
98   AliITSHLTforSDD *hltSDD=new AliITSHLTforSDD();
99   TString hltMode = GetRunParameter("HLTmode");
100   TSubString firstChar = hltMode(0,1);
101   if (firstChar == "C") hltSDD->SetHLTmodeC(kTRUE);
102   else hltSDD->SetHLTmodeC(kFALSE);
103
104   AliCDBMetaData *md= new AliCDBMetaData();
105   md->SetResponsible("Francesco Prino");
106   md->SetBeamPeriod(0);
107   md->SetComment("HLT mode C flag for PHYSICS run");
108   Bool_t retCode = Store("Calib","HLTforSDD",hltSDD,md);
109   if(retCode) return 0;
110   else return 1;
111 }
112 //______________________________________________________________________
113 UInt_t AliITSPreprocessorSDD::ProcessPulser(AliITSDDLModuleMapSDD* ddlmap){
114   // Process FXS files from PULSER run (baseline, noise, gain)
115   // returns 0 in case of success, 
116   //         1 in case of storage error, 
117   //         2 in case of error with input files
118   TObjArray calSDD(kNumberOfSDD);
119   calSDD.SetOwner(kFALSE);
120
121   Float_t baseline,rawnoise,cmn,corn,gain;
122   Int_t isgoodan,i,im,is,isgoodmod,basmin,basoff;
123   Int_t th,tl;
124   Int_t numOfBadChannels[kNumberOfSDD];
125   
126   TList* sourceList = GetFileSources(kDAQ, "SDD_Calib");
127   if (!sourceList){ 
128     Log("Error: no sources found for SDD_Calib");
129     return 2;
130   }
131
132   Int_t ind = 0;
133   while (sourceList->At(ind)!=NULL) {
134     TObjString* tarId = (TObjString*) sourceList->At(ind);
135     TString tarName = GetFile(kDAQ, "SDD_Calib", tarId->GetString().Data());
136     if(tarName.Length()==0){
137       Log(Form("Baseline tar file from source %d not found.",ind));
138       return 2;
139     }
140     TString command;
141     command.Form("tar -xf %s",tarName.Data());
142     gSystem->Exec(command);
143     ind++;
144   }
145   delete sourceList;
146   
147   for(Int_t iddl=0;iddl<kNumberOfDDL;iddl++){
148     for(Int_t imod=0;imod<kModulesPerDDL;imod++){
149       Int_t modID=ddlmap->GetModuleNumber(iddl,imod);
150       if(modID==-1) continue;
151       modID-=240; // to have SDD modules numbering from 0 to 260
152       AliITSCalibrationSDD *cal = new AliITSCalibrationSDD("simulated");
153       cal->SetUseCorrectionMaps(0,0); // temporary disabling of maps
154       cal->SetAMAt20MHz();            // for runs > 51275 with clock at 20 MHz
155       numOfBadChannels[modID]=0;
156       Int_t badch[kNumberOfChannels];
157       for(Int_t isid=0;isid<=1;isid++){
158         TString inpFileName;
159         inpFileName.Form("./SDDbase_ddl%02dc%02d_sid%d.data",iddl,imod,isid);
160
161         FILE* basFil = fopen(inpFileName,"read");
162         if (basFil == 0) {
163           Log(Form("File %s not found.",inpFileName.Data()));
164           cal->SetBad();
165           continue;
166         }
167         fscanf(basFil,"%d %d %d\n",&im,&is,&isgoodmod);
168         if(!isgoodmod) cal->SetBad();
169         fscanf(basFil,"%d\n",&th);
170         fscanf(basFil,"%d\n",&tl);
171         cal->SetZSLowThreshold(isid,tl);
172         cal->SetZSHighThreshold(isid,th);
173         for(Int_t ian=0;ian<(kNumberOfChannels/2);ian++){
174           fscanf(basFil,"%d %d %f %d %d %f %f %f %f\n",&i,&isgoodan,&baseline,&basmin,&basoff,&rawnoise,&cmn,&corn,&gain);
175           Int_t ich=ian;
176           if(isid==1) ich+=256;
177           if(!isgoodan){ 
178             Int_t ibad=numOfBadChannels[modID];
179             badch[ibad]=ich;
180             numOfBadChannels[modID]++;
181           }
182           cal->SetBaseline(ich,baseline-basoff);
183           cal->SetNoiseAfterElectronics(ich,rawnoise);
184           cal->SetGain(ich,gain);
185         }
186         cal->SetDeadChannels(numOfBadChannels[modID]);
187         for(Int_t ibad=0;ibad<numOfBadChannels[modID];ibad++){
188           cal->SetBadChannel(ibad,badch[ibad]);
189         }
190         fclose(basFil);
191       }
192       Log(Form("Put calib obj for module %d (DDL %d  Carlos %d)",modID,iddl,imod));
193       calSDD.AddAt(cal,modID);
194     }
195   }
196   AliCDBMetaData *md= new AliCDBMetaData();
197   md->SetResponsible("Francesco Prino");
198   md->SetBeamPeriod(0);
199   md->SetComment("AliITSCalibrationSDD from PEDESTAL+PULSER runs");
200   Bool_t retCode = Store("Calib","CalibSDD",&calSDD,md, 0, kTRUE);
201   if(retCode) return 0;
202   else return 1;
203 }
204 //______________________________________________________________________
205 UInt_t AliITSPreprocessorSDD::ProcessInjector(AliITSDDLModuleMapSDD* ddlmap){
206   // Process FXS files from injector events (INJECTOR or PHYSICS runs)
207   // returns 0 in case of success, 
208   //         1 in case of storage error, 
209   //         2 in case of error with input files
210   TObjArray vdrift(2*kNumberOfSDD);
211   vdrift.SetOwner(kFALSE);
212   Int_t evNumb,polDeg; 
213   UInt_t timeStamp;
214   Bool_t modSet[2*kNumberOfSDD]; // flag modules with good inj.
215   for(Int_t ihyb=0; ihyb<2*kNumberOfSDD; ihyb++) modSet[ihyb]=0;
216   Double_t nPt = 0;
217
218   Double_t param[4];    // parameters of poly fit
219   Double_t minValP0=4.; // min value for param[0]
220   Double_t maxValP0=9.; // max value for param[0]
221   Double_t minValP1=0.; // min value for param[1]
222   Double_t aveCoef[4]={0.,0.,0.,0.};  // average param for good mod.
223   Double_t defCoef[4]={6.53227,0.00128941,-5.14493e-06,0};  // default values for param
224   Float_t auxP;
225
226   TList* sourceList = GetFileSources(kDAQ, "SDD_Injec");
227   if (!sourceList){ 
228     Log("Error: no sources found for SDD_Injec");
229     return 2;
230   }
231   Int_t ind = 0;
232   while (sourceList->At(ind)!=NULL) {
233     TObjString* tarId = (TObjString*) sourceList->At(ind);
234     TString tarName = GetFile(kDAQ, "SDD_Injec", tarId->GetString().Data());
235     if(tarName.Length()==0){
236       Log(Form("Injector tar file from source %d not found.",ind));
237       return 2;
238     }
239     TString command;
240     command.Form("tar -xf %s",tarName.Data());
241     gSystem->Exec(command);
242     ind++;
243   }
244   delete sourceList;
245
246
247   for(Int_t iddl=0;iddl<kNumberOfDDL;iddl++){
248     for(Int_t imod=0;imod<kModulesPerDDL;imod++){
249       Int_t modID=ddlmap->GetModuleNumber(iddl,imod);
250       if(modID==-1) continue;
251       modID-=240; // to have SDD modules numbering from 0 to 260
252       for(Int_t isid=0;isid<=1;isid++){
253         AliITSDriftSpeedArraySDD *arr=new AliITSDriftSpeedArraySDD();
254         TString inpFileName;
255         inpFileName.Form("./SDDinj_ddl%02dc%02d_sid%d.data",iddl,imod,isid);
256         FILE* injFil = fopen(inpFileName,"read");
257         if (injFil == 0) {
258           Log(Form("File %s not found.",inpFileName.Data()));
259           AliITSDriftSpeedSDD *dsp=new AliITSDriftSpeedSDD();
260           arr->AddDriftSpeed(dsp);
261           vdrift.AddAt(arr,2*modID+isid);
262           continue;
263         }
264         fscanf(injFil,"%d",&polDeg);
265         while (!feof(injFil)){
266           fscanf(injFil,"%d %d ",&evNumb,&timeStamp);
267           if(feof(injFil)) break;
268           for(Int_t ic=0;ic<4;ic++){ 
269             fscanf(injFil,"%f ",&auxP);
270             param[ic]=auxP;
271           }
272
273           if(param[0]>minValP0 && param[0]<maxValP0 && param[1]>minValP1){
274             for(Int_t ic=0;ic<4;ic++) aveCoef[ic]+=param[ic];
275             nPt++;
276             AliITSDriftSpeedSDD *dsp=new AliITSDriftSpeedSDD(evNumb,timeStamp,polDeg,param);
277             arr->AddDriftSpeed(dsp);
278             modSet[2*modID+isid]=1;
279           }
280         }
281         Log(Form("Put calib obj for hybrid %d (DDL %d  Carlos %d)",2*modID+isid,iddl,imod));
282         if(modSet[2*modID+isid]) vdrift.AddAt(arr,2*modID+isid);
283       }
284     }
285   }
286
287   // set drift speed for modules with bad injectors
288   for(Int_t ic=0;ic<4;ic++){ 
289     if(nPt>0) aveCoef[ic]/=nPt; // mean parameters
290     else aveCoef[ic]=defCoef[ic]; // default parameters
291   }
292   AliITSDriftSpeedSDD *avdsp=new AliITSDriftSpeedSDD(evNumb,timeStamp,polDeg,aveCoef);
293
294   for(Int_t ihyb=0; ihyb<2*kNumberOfSDD; ihyb++){
295     if(modSet[ihyb]==0){ 
296       AliWarning(Form("No good injector events for mod. %d --> use average values",ihyb/2));
297       AliITSDriftSpeedArraySDD *arr=new AliITSDriftSpeedArraySDD();
298       arr->AddDriftSpeed(avdsp);
299       vdrift.AddAt(arr,ihyb);
300     }
301   }
302
303
304   AliCDBMetaData *md= new AliCDBMetaData();
305   md->SetResponsible("Francesco Prino");
306   md->SetBeamPeriod(0);
307   md->SetComment("AliITSDriftSpeedSDD from injector events");
308   Bool_t retCode = Store("Calib","DriftSpeedSDD",&vdrift,md,0, kTRUE);
309   if(retCode) return 0;
310   else return 1;
311 }
312 //______________________________________________________________________
313 Bool_t AliITSPreprocessorSDD::ProcessDCSDataPoints(TMap* dcsAliasMap){
314   // Process DCS data
315   AliITSDCSAnalyzerSDD *dcs=new AliITSDCSAnalyzerSDD();
316   dcs->AnalyzeData(dcsAliasMap);
317   TObjArray refDCS(kNumberOfSDD);
318   refDCS.SetOwner(kFALSE);
319   for(Int_t imod=0;imod<kNumberOfSDD;imod++){
320     AliITSDCSDataSDD *dcsdata=dcs->GetDCSData(imod);
321     refDCS.Add(dcsdata);
322   }    
323   AliCDBMetaData *md= new AliCDBMetaData();
324   md->SetResponsible("Francesco Prino");
325   md->SetBeamPeriod(0);
326   md->SetComment("AliITSDCSDataSDD objects from DCS DB");
327   Bool_t retCode = StoreReferenceData("DCS","DataSDD",&refDCS,md);
328   return retCode;
329 }
330