]>
Commit | Line | Data |
---|---|---|
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 | /* $Id: AliTRDCalibViewer.cxx 40390 2010-04-14 09:43:23Z cblume $ */ | |
17 | ||
18 | /////////////////////////////////////////////////////////////////////////////// | |
19 | // // | |
20 | // Class which implements AliBaseCalibViewer for the TRD // | |
21 | // used for the calibration monitor // | |
22 | // // | |
23 | // Authors: Marian Ivanov (Marian.Ivanov@cern.ch) // | |
24 | // Jens Wiechula (Jens.Wiechula@cern.ch) // | |
25 | // Ionut Arsene (iarsene@cern.ch) // | |
26 | // // | |
27 | /////////////////////////////////////////////////////////////////////////////// | |
28 | ||
29 | #include <iostream> | |
30 | #include <fstream> | |
31 | #include <TString.h> | |
32 | #include <TRandom.h> | |
33 | #include <TLegend.h> | |
34 | #include <TLine.h> | |
35 | #include <TCanvas.h> | |
36 | #include <TROOT.h> | |
37 | #include <TStyle.h> | |
38 | #include <TH1.h> | |
39 | #include <TH1F.h> | |
40 | #include <TMath.h> | |
41 | #include <TVectorD.h> | |
42 | #include <THashTable.h> | |
43 | #include <TObjString.h> | |
44 | #include <TTimeStamp.h> | |
45 | #include <TObjString.h> | |
46 | #include <TTreeStream.h> | |
47 | #include <TFile.h> | |
48 | #include <TKey.h> | |
49 | #include <TGraph.h> | |
50 | #include <TDirectory.h> | |
51 | #include <TFriendElement.h> | |
52 | #include <TGrid.h> | |
53 | #include <TGeoManager.h> | |
54 | #include "AliTRDCalDet.h" | |
55 | #include "AliTRDCalPad.h" | |
56 | #include "AliTRDCalROC.h" | |
57 | #include "AliTRDCalChamberStatus.h" | |
58 | #include "AliTRDCalSingleChamberStatus.h" | |
59 | #include "AliTRDCalPadStatus.h" | |
60 | #include "AliTRDCalDCSv2.h" | |
61 | #include "AliTRDCalDCSFEEv2.h" | |
62 | #include "AliTRDcalibDB.h" | |
63 | #include "AliCDBManager.h" | |
64 | #include "AliCDBStorage.h" | |
65 | #include "AliCDBEntry.h" | |
66 | #include "AliGRPObject.h" | |
67 | #include "AliTRDalignment.h" | |
68 | #include "AliTRDgeometry.h" | |
69 | #include "AliTRDpadPlane.h" | |
70 | ||
71 | #include "AliTRDCalibViewer.h" | |
72 | ||
73 | ||
74 | using namespace std; | |
75 | ||
76 | ClassImp(AliTRDCalibViewer) | |
77 | ||
78 | //_____________________________________________________________________________ | |
79 | AliTRDCalibViewer::AliTRDCalibViewer() | |
80 | :AliBaseCalibViewer() | |
81 | { | |
82 | // | |
83 | // Default constructor (just call base class constructor) | |
84 | // | |
85 | } | |
86 | ||
87 | //_____________________________________________________________________________ | |
88 | AliTRDCalibViewer::AliTRDCalibViewer(const AliTRDCalibViewer &c) | |
89 | :AliBaseCalibViewer(c) | |
90 | { | |
91 | // | |
92 | // copy constructor (just call base class copy constructor) | |
93 | // | |
94 | } | |
95 | ||
96 | //_____________________________________________________________________________ | |
97 | AliTRDCalibViewer::AliTRDCalibViewer(TTree* tree) | |
98 | :AliBaseCalibViewer(tree) | |
99 | { | |
100 | // | |
101 | // Constructor (just call the corresponding base constructor) | |
102 | // | |
103 | } | |
104 | ||
105 | //_____________________________________________________________________________ | |
106 | AliTRDCalibViewer::AliTRDCalibViewer(const char* fileName, const char* treeName) | |
107 | :AliBaseCalibViewer(fileName, treeName) | |
108 | { | |
109 | // | |
110 | // Constructor (just call the corresponding base constructor) | |
111 | // | |
112 | } | |
113 | ||
114 | //_____________________________________________________________________________ | |
115 | AliTRDCalibViewer& AliTRDCalibViewer::operator=(const AliTRDCalibViewer& param) { | |
116 | // | |
117 | // assignment operator | |
118 | // | |
119 | fTree = param.fTree; | |
120 | fTreeMustBeDeleted = param.fTreeMustBeDeleted; | |
121 | fListOfObjectsToBeDeleted = param.fListOfObjectsToBeDeleted; | |
122 | fAbbreviation = param.fAbbreviation; | |
123 | fAppendString = param.fAppendString; | |
124 | return(*this); | |
125 | } | |
126 | ||
127 | //_____________________________________________________________________________ | |
128 | AliTRDCalibViewer::~AliTRDCalibViewer() | |
129 | { | |
130 | // | |
131 | // AliTRDCalibViewer destructor | |
132 | // do nothing, the base class destructor will do the job | |
133 | } | |
134 | ||
135 | /* | |
136 | //_____________________________________________________________________________ | |
137 | void AliTRDCalibViewer::GetTimeInfoOCDB(const Char_t* runList, const Char_t* outFile, | |
138 | Int_t firstRun, Int_t lastRun, UInt_t infoFlags, | |
139 | const Char_t* ocdbStorage) { | |
140 | // | |
141 | // Get time information from OCDB by calling the DumpOCDBtoTree.C macro | |
142 | // | |
143 | DumpOCDBtoTree(runList, outFile, firstRun, lastRun, | |
144 | TESTBIT(infoFlags,1), TESTBIT(infoFlags,2), | |
145 | TESTBIT(infoFlags,3), TESTBIT(infoFlags,4), | |
146 | ocdbStorage); | |
147 | } | |
148 | */ | |
149 | ||
150 | //_____________________________________________________________________________ | |
151 | const char* AliTRDCalibViewer::AddAbbreviations(char* c, Bool_t printDrawCommand){ | |
152 | // Replace all "<variable>" with "<variable><fAbbreviation>" (Adds forgotten "~") | |
153 | // but take care on the statistical information, like "CEQmean_Mean" | |
154 | // and also take care on correct given variables, like "CEQmean~" | |
155 | // | |
156 | // For each variable out of "listOfVariables": | |
157 | // - 'Save' correct items: | |
158 | // - form <replaceString>, take <variable>'s first char, add <removeString>, add rest of <variable>, e.g. "C!#EQmean" (<removeString> = "!#") | |
159 | // - For each statistical information in "listOfNormalizationVariables": | |
160 | // - ReplaceAll <variable><statistical_Information> with <replaceString><statistical_Information> | |
161 | // - ReplaceAll <variable><abbreviation> with <replaceString><abbreviation>, e.g. "CEQmean~" -> "C!#EQmean~" | |
162 | // - ReplaceAll <variable><appendStr> with <replaceString><appendStr>, e.g. "CEQmean.fElements" -> "C!#EQmean.fElements" | |
163 | // | |
164 | // - Do actual replacing: | |
165 | // - ReplaceAll <variable> with <variable><fAbbreviation>, e.g. "CEQmean" -> "CEQmean~" | |
166 | // | |
167 | // - Undo saving: | |
168 | // - For each statistical information in "listOfNormalizationVariables": | |
169 | // - ReplaceAll <replaceString><statistical_Information> with <variable><statistical_Information> | |
170 | // - ReplaceAll <replaceString><abbreviation> with <variable><abbreviation>, e.g. "C!#EQmean~" -> "CEQmean~" | |
171 | // - ReplaceAll <replaceString><appendStr> with <variable><appendStr>, e.g. "C!#EQmean.fElements" -> "CEQmean.fElements" | |
172 | // | |
173 | // Now all the missing "~" should be added. | |
174 | ||
175 | TString str(c); | |
176 | TString removeString = "!#"; // very unprobable combination of chars | |
177 | TString replaceString = ""; | |
178 | TString searchString = ""; | |
179 | TString normString = ""; | |
180 | TObjArray *listOfVariables = GetListOfVariables(); | |
181 | // variables used for mapping the pads, mcms, ... | |
182 | listOfVariables->Add(new TObjString("SuperModule")); | |
183 | listOfVariables->Add(new TObjString("Layer")); | |
184 | listOfVariables->Add(new TObjString("Stack")); | |
185 | listOfVariables->Add(new TObjString("Channel")); | |
186 | listOfVariables->Add(new TObjString("Row")); | |
187 | listOfVariables->Add(new TObjString("Column")); | |
188 | listOfVariables->Add(new TObjString("Chamber")); | |
189 | listOfVariables->Add(new TObjString("PadSuperRow")); | |
190 | listOfVariables->Add(new TObjString("PadSuperColumn")); | |
191 | listOfVariables->Add(new TObjString("MCMSuperRow")); | |
192 | listOfVariables->Add(new TObjString("MCMSuperColumn")); | |
193 | listOfVariables->Add(new TObjString("ROB")); | |
194 | listOfVariables->Add(new TObjString("MCM")); | |
195 | TObjArray *listOfNormalizationVariables = GetListOfNormalizationVariables(); | |
196 | Int_t nVariables = listOfVariables->GetEntriesFast(); | |
197 | Int_t nNorm = listOfNormalizationVariables->GetEntriesFast(); | |
198 | ||
199 | Int_t *varLengths = new Int_t[nVariables]; | |
200 | for (Int_t i = 0; i < nVariables; i++) { | |
201 | varLengths[i] = ((TObjString*)listOfVariables->At(i))->String().Length(); | |
202 | } | |
203 | Int_t *normLengths = new Int_t[nNorm]; | |
204 | for (Int_t i = 0; i < nNorm; i++) { | |
205 | normLengths[i] = ((TObjString*)listOfNormalizationVariables->At(i))->String().Length(); | |
206 | } | |
207 | Int_t *varSort = new Int_t[nVariables+1]; | |
208 | TMath::Sort(nVariables, varLengths, varSort, kTRUE); | |
209 | Int_t *normSort = new Int_t[nNorm+1]; | |
210 | TMath::Sort(nNorm, normLengths, normSort, kTRUE); | |
211 | ||
212 | for (Int_t ivar = 0; ivar < nVariables; ivar++) { | |
213 | // ***** save correct tokens ***** | |
214 | // first get the next variable: | |
215 | searchString = ((TObjString*)listOfVariables->At(varSort[ivar]))->String(); | |
216 | // form replaceString: | |
217 | replaceString = ""; | |
218 | for (Int_t i = 0; i < searchString.Length(); i++) { | |
219 | replaceString.Append(searchString[i]); | |
220 | if (i == 0) replaceString.Append(removeString); | |
221 | } | |
222 | // go through normalization: | |
223 | for (Int_t inorm = 0; inorm < nNorm; inorm++) { | |
224 | normString = ((TObjString*)listOfNormalizationVariables->At(normSort[inorm]))->String(); | |
225 | str.ReplaceAll(searchString + normString, replaceString + normString); | |
226 | // like: str.ReplaceAll("CEQmean_Mean", "C!EQmean_Mean"); | |
227 | } | |
228 | str.ReplaceAll(searchString + fAbbreviation, replaceString + fAbbreviation); | |
229 | // like: str.ReplaceAll("CEQmean~", "C!EQmean~"); | |
230 | str.ReplaceAll(searchString + fAppendString, replaceString + fAppendString); | |
231 | // like: str.ReplaceAll("CEQmean.fElements", "C!EQmean.fElements"); | |
232 | ||
233 | // ***** add missing extensions ***** | |
234 | str.ReplaceAll(searchString, replaceString + fAbbreviation); | |
235 | // like: str.ReplaceAll("CEQmean", "C!EQmean~"); | |
236 | } | |
237 | ||
238 | // ***** undo saving ***** | |
239 | str.ReplaceAll(removeString, ""); | |
240 | ||
241 | if (printDrawCommand) std::cout << "The string looks now like: " << str.Data() << std::endl; | |
242 | delete [] varSort; | |
243 | delete [] normSort; | |
244 | return str.Data(); | |
245 | } | |
246 | ||
247 | //_____________________________________________________________________________ | |
248 | TObjArray* AliTRDCalibViewer::GetListOfVariables(Bool_t printList) { | |
249 | // | |
250 | // scan the tree - produces a list of available variables in the tree | |
251 | // printList: print the list to the screen, after the scan is done | |
252 | // | |
253 | TObjArray* arr = new TObjArray(); | |
254 | TObjString* str = 0; | |
255 | if (!fTree) { | |
256 | return 0; | |
257 | } | |
258 | Int_t nentries = fTree->GetListOfBranches()->GetEntries(); | |
259 | for (Int_t i = 0; i < nentries; i++) { | |
260 | str = new TObjString(fTree->GetListOfBranches()->At(i)->GetName()); | |
261 | str->String().ReplaceAll("_Mean", ""); | |
262 | str->String().ReplaceAll("_RMS", ""); | |
263 | str->String().ReplaceAll("_Median", ""); | |
264 | str->String().ReplaceAll(".", ""); | |
265 | str->String().ReplaceAll("_Run", ""); | |
266 | str->String().ReplaceAll("_SuperModule", ""); | |
267 | str->String().ReplaceAll("_Chamber", ""); | |
268 | // add all the variables in the tree to a list | |
269 | // exception make variables which are used for mapping, specified in AddAbbreviations() | |
270 | // These two functions should be kept synchronized with respect to the mapping variables | |
271 | if (!arr->FindObject(str) && | |
272 | !(str->String() == "run" || | |
273 | str->String() == "SuperModule" || str->String() == "Layer" || str->String() == "Stack" || | |
274 | str->String() == "Chamber" || | |
275 | str->String() == "Channel" || str->String() == "Row" || str->String() == "Column" || | |
276 | str->String() == "PadSuperRow" || str->String() == "PadSuperColumn" || str->String() == "MCMSuperRow" | |
277 | || str->String() == "MCMSuperColumn" || str->String() == "MCM" || str->String() == "ROB")) { | |
278 | arr->Add(str); | |
279 | } | |
280 | } | |
281 | ||
282 | // loop over all friends (if there are some) and add them to the list | |
283 | if (fTree->GetListOfFriends()) { | |
284 | for (Int_t ifriend = 0; ifriend < fTree->GetListOfFriends()->GetEntries(); ifriend++){ | |
285 | // printf("iterating through friendlist, currently at %i\n", ifriend); | |
286 | // printf("working with %s\n", fTree->GetListOfFriends()->At(ifriend)->ClassName()); | |
287 | if (TString(fTree->GetListOfFriends()->At(ifriend)->ClassName()) != "TFriendElement") continue; // no friendElement found | |
288 | TFriendElement *friendElement = (TFriendElement*)fTree->GetListOfFriends()->At(ifriend); | |
289 | if (friendElement->GetTree() == 0) continue; // no tree found in friendElement | |
290 | // printf("friend found \n"); | |
291 | for (Int_t i = 0; i < friendElement->GetTree()->GetListOfBranches()->GetEntries(); i++) { | |
292 | // printf("iterating through friendelement entries, currently at %i\n", i); | |
293 | str = new TObjString(friendElement->GetTree()->GetListOfBranches()->At(i)->GetName()); | |
294 | str->String().ReplaceAll("_Mean", ""); | |
295 | str->String().ReplaceAll("_RMS", ""); | |
296 | str->String().ReplaceAll("_Median", ""); | |
297 | str->String().ReplaceAll(".", ""); | |
298 | str->String().ReplaceAll("_Run", ""); | |
299 | str->String().ReplaceAll("_SuperModule", ""); | |
300 | str->String().ReplaceAll("_Chamber", ""); | |
301 | if (!(str->String() == "run" || | |
302 | str->String() == "SuperModule" || str->String() == "Layer" || str->String() == "Stack" || | |
303 | str->String() == "Chamber" || | |
304 | str->String() == "Channel" || str->String() == "Row" || str->String() == "Column" || | |
305 | str->String() == "PadSuperRow" || str->String() == "PadSuperColumn" || str->String() == "MCMSuperRow" | |
306 | || str->String() == "MCMSuperColumn" || str->String() == "MCM" || str->String() == "ROB")){ | |
307 | // insert "<friendName>." at the beginning: (<friendName> is per default "R") | |
308 | str->String().Insert(0, "."); | |
309 | str->String().Insert(0, friendElement->GetName()); | |
310 | if (!arr->FindObject(str)) { | |
311 | arr->Add(str); | |
312 | } | |
313 | // printf("added string %s \n", str->String().Data()); | |
314 | } | |
315 | } | |
316 | } | |
317 | } // if (fTree->GetListOfFriends()) | |
318 | ||
319 | arr->Sort(); | |
320 | ||
321 | if (printList) { | |
322 | TIterator* iter = arr->MakeIterator(); | |
323 | iter->Reset(); | |
324 | TObjString* currentStr = 0; | |
325 | while ( (currentStr = (TObjString*)(iter->Next())) ) { | |
326 | std::cout << currentStr->GetString().Data() << std::endl; | |
327 | } | |
328 | delete iter; | |
329 | } | |
330 | return arr; | |
331 | } | |
332 | ||
333 | TObjArray* AliTRDCalibViewer::GetListOfNormalizationVariables(Bool_t printList) const{ | |
334 | // | |
335 | // produces a list of available variables for normalization in the tree | |
336 | // printList: print the list to the screen, after the scan is done | |
337 | // | |
338 | TObjArray* arr = new TObjArray(); | |
339 | arr->Add(new TObjString("_Mean_Run")); | |
340 | arr->Add(new TObjString("_Mean_SuperModule")); | |
341 | arr->Add(new TObjString("_Mean_Chamber")); | |
342 | arr->Add(new TObjString("_Median_Run")); | |
343 | arr->Add(new TObjString("_Median_SuperModule")); | |
344 | arr->Add(new TObjString("_Median_Chamber")); | |
345 | ||
346 | if (printList) { | |
347 | TIterator* iter = arr->MakeIterator(); | |
348 | iter->Reset(); | |
349 | TObjString* currentStr = 0; | |
350 | while ((currentStr = (TObjString*)(iter->Next()))) { | |
351 | std::cout << currentStr->GetString().Data() << std::endl; | |
352 | } | |
353 | delete iter; | |
354 | } | |
355 | return arr; | |
356 | } | |
357 | ||
358 | void AliTRDCalibViewer::GetLayerSectorStack(TString trdString, Int_t& layerNo, Int_t& sectorNo, Int_t& stackNo) const { | |
359 | // Get the layer, sector and stack numbers out of a string | |
360 | // encoded with the following format: | |
361 | // Layer%dSector%dStack%d | |
362 | ||
363 | //sscanf(trdString.Data(), "Layer%1dSector%02dStack%1d", &layerNo, §orNo, &stackNo); | |
364 | ||
365 | // Coverity compliant solution (bit more cumbersome, but works) CBL | |
366 | TString cName = trdString.Data(); | |
367 | Char_t cLayer[2]; | |
368 | Char_t cSector[3]; | |
369 | Char_t cStack[2]; | |
370 | ||
371 | cLayer[0] = cName[5]; | |
372 | cLayer[1] = 0; | |
373 | cSector[0] = cName[12]; | |
374 | cSector[1] = cName[13]; | |
375 | cSector[2] = 0; | |
376 | cStack[0] = cName[19]; | |
377 | cStack[1] = 0; | |
378 | ||
379 | layerNo = atoi(cLayer); | |
380 | sectorNo = atoi(cSector); | |
381 | stackNo = atoi(cStack); | |
382 | ||
383 | return; | |
384 | } | |
385 | ||
386 | //_____________________________________________________________________________ | |
387 | Int_t AliTRDCalibViewer::EasyDraw(const char* drawCommand, const char* sector, const char* cuts, const char* drawOptions, Bool_t writeDrawCommand) const { | |
388 | // | |
389 | // easy drawing of data, use '~' for abbreviation of '.fElements' | |
390 | // example: EasyDraw("CETmean~-CETmean_mean", "A", "(CETmean~-CETmean_mean)>0") | |
391 | // sector: sector-number - only the specified sector will be drwawn | |
392 | // 'A'/'C' or 'a'/'c' - side A/C will be drawn | |
393 | // 'ALL' - whole TPC will be drawn, projected on one side | |
394 | // cuts: specifies cuts | |
395 | // drawOptions: draw options like 'same' | |
396 | // writeDrawCommand: write the command, that is passed to TTree::Draw | |
397 | // | |
398 | ||
399 | TString drawStr(drawCommand); | |
400 | ||
401 | TString sectorStr(sector); | |
402 | Int_t layerNo = -1; | |
403 | Int_t sectorNo = -1; | |
404 | Int_t stackNo = -1; | |
405 | GetLayerSectorStack(sectorStr, layerNo, sectorNo, stackNo); | |
406 | if(layerNo==-1) { | |
407 | Warning("EasyDraw", "The sector string must always contain the Layer number!"); | |
408 | return -1; | |
409 | } | |
410 | if(layerNo<0 || layerNo>5) { | |
411 | Warning("EasyDraw", "The Layer number must be in the range [0,5] !"); | |
412 | return -1; | |
413 | } | |
414 | if(sectorNo!=-1 && (sectorNo<0 || sectorNo>17)) { | |
415 | Warning("EasyDraw", "The SuperModule number must be in the range [0,17] !"); | |
416 | return -1; | |
417 | } | |
418 | if(stackNo!=-1 && (stackNo<0 || stackNo>4)) { | |
419 | Warning("EasyDraw", "The Stack number must be in the range [0,4] !"); | |
420 | return -1; | |
421 | } | |
422 | ||
423 | TString cutStr(""); | |
424 | ||
425 | Bool_t dangerousToDraw = drawStr.Contains(":") || drawStr.Contains(">>"); | |
426 | if (dangerousToDraw) { | |
427 | Warning("EasyDraw", "The draw string must not contain ':' or '>>'. Using only first variable for drawing!"); | |
428 | drawStr.Resize(drawStr.First(":")); | |
429 | } | |
430 | ||
431 | TString drawOptionsStr(""); | |
432 | TRandom rnd(0); | |
433 | Int_t rndNumber = rnd.Integer(10000); | |
434 | ||
435 | if (drawOptions && strcmp(drawOptions, "") != 0) | |
436 | drawOptionsStr += drawOptions; | |
437 | else | |
438 | drawOptionsStr += "profcolz"; | |
439 | ||
440 | const Int_t gkNRows[ 5] = {16, 16, 12, 16, 16}; // number of pad rows in the chambers from each of the 5 stacks | |
441 | ||
442 | // draw calibration stuff | |
443 | if(drawStr.Contains("Status") || drawStr.Contains("Gain") || drawStr.Contains("Noise") || | |
444 | drawStr.Contains("Vdrift") || drawStr.Contains("T0") || | |
445 | drawStr.Contains("gain") || drawStr.Contains("chiSquare")) { | |
446 | if(sectorNo==-1 && stackNo==-1) { // plot the entire layer | |
447 | drawStr += Form(":PadSuperColumn%s:PadSuperRow%s>>prof", fAppendString.Data(), fAppendString.Data()); | |
448 | drawStr += rndNumber; | |
449 | drawStr += "(76,-0.5,75.5,2592,-0.5,2591.5)"; | |
450 | cutStr += Form("Layer==%d", layerNo); | |
451 | } | |
452 | else if(sectorNo!=-1 && stackNo==-1) { // plot a sector from a layer | |
453 | drawStr += Form(":Column%s:PadSuperRow%s>>prof", fAppendString.Data(), fAppendString.Data()); | |
454 | drawStr += rndNumber; | |
455 | drawStr += "(76,-0.5,75.5,144,-0.5,143.5)"; | |
456 | cutStr += Form("Layer==%d && SuperModule==%d", layerNo, sectorNo); | |
457 | } | |
458 | else if(sectorNo==-1 && stackNo!=-1) { // plot a stack from a layer | |
459 | drawStr += Form(":PadSuperColumn%s:Row%s>>prof", fAppendString.Data(), fAppendString.Data()); | |
460 | drawStr += rndNumber; | |
461 | drawStr += Form("(%d,-0.5,%d-0.5,2592,-0.5,2591.5)", gkNRows[stackNo], gkNRows[stackNo]); | |
462 | cutStr += Form("Layer==%d && Stack==%d", layerNo, stackNo); | |
463 | } | |
464 | else { // the layer, sector and stack are determined -> so plot a chamber | |
465 | drawStr += Form(":Column%s:Row%s>>prof", fAppendString.Data(), fAppendString.Data()); | |
466 | drawStr += rndNumber; | |
467 | drawStr += Form("(%d,-0.5,%d-0.5,144,-0.5,143.5)", gkNRows[stackNo], gkNRows[stackNo]); | |
468 | cutStr += Form("Layer==%d && SuperModule==%d && Stack==%d", layerNo, sectorNo, stackNo); | |
469 | } | |
470 | } | |
471 | // draw FEE stuff | |
472 | else if(drawStr.Contains("SORandEOR") || | |
473 | drawStr.Contains("gsmSOR") || drawStr.Contains("gsmDelta") || | |
474 | drawStr.Contains("nimSOR") || drawStr.Contains("nimDelta") || | |
475 | drawStr.Contains("nevSOR") || drawStr.Contains("nevDelta") || | |
476 | drawStr.Contains("nptSOR") || drawStr.Contains("nptDelta")) { | |
477 | if(sectorNo==-1 && stackNo==-1) { // plot the entire layer | |
478 | drawStr += Form(":MCMSuperColumn%s:MCMSuperRow%s>>prof", fAppendString.Data(), fAppendString.Data()); | |
479 | drawStr += rndNumber; | |
480 | drawStr += "(76,-0.5,75.5,144,-0.5,143.5)"; | |
481 | cutStr += Form("Layer==%d", layerNo); | |
482 | } | |
483 | else if(sectorNo!=-1 && stackNo==-1) { // plot a sector from a layer | |
484 | drawStr += Form(":MCMSuperColumn%s:MCMSuperRow%s>>prof", fAppendString.Data(), fAppendString.Data()); | |
485 | drawStr += rndNumber; | |
486 | drawStr += "(76,-0.5,75.5,144,-0.5,143.5)"; | |
487 | cutStr += Form("Layer==%d && SuperModule==%d", layerNo, sectorNo); | |
488 | } | |
489 | else if(sectorNo==-1 && stackNo!=-1) { // plot a stack from a layer | |
490 | drawStr += Form(":MCMSuperColumn%s:MCMSuperRow%s>>prof", fAppendString.Data(), fAppendString.Data()); | |
491 | drawStr += rndNumber; | |
492 | // drawStr += Form("(%d,-0.5,%d-0.5,2592,-0.5,2591.5)", gkNRows[stackNo], gkNRows[stackNo]); | |
493 | drawStr += "(76,-0.5,75.5,144,-0.5,143.5)"; | |
494 | cutStr += Form("Layer==%d && Stack==%d", layerNo, stackNo); | |
495 | } | |
496 | else { // the layer, sector and stack are determined -> so plot a chamber | |
497 | drawStr += Form(":ROB%s:MCM%s>>prof", fAppendString.Data(), fAppendString.Data()); | |
498 | drawStr += rndNumber; | |
499 | drawStr += Form("(16,-0.5,15.5,%d,-0.5,%d-0.5)", gkNRows[stackNo]/2, gkNRows[stackNo]/2); | |
500 | cutStr += Form("Layer==%d && SuperModule==%d && Stack==%d", layerNo, sectorNo, stackNo); | |
501 | } | |
502 | } | |
503 | // draw alignment stuff | |
504 | else if(drawStr.Contains("Align")) { | |
505 | if(sectorNo==-1 && stackNo==-1) { // plot the entire layer | |
506 | drawStr += ":SuperModule:Stack>>prof"; | |
507 | drawStr += rndNumber; | |
508 | drawStr += "(5,-0.5,4.5,18,-0.5,17.5)"; | |
509 | cutStr += Form("Layer==%d", layerNo); | |
510 | } | |
511 | else if(sectorNo!=-1 && stackNo==-1) { // plot a sector from a layer | |
512 | drawStr += ":SuperModule:Stack>>prof"; | |
513 | drawStr += rndNumber; | |
514 | drawStr += Form("(5,-0.5,4.5,1,%f,%f)", sectorNo-0.5, sectorNo+0.5); | |
515 | cutStr += Form("Layer==%d && SuperModule==%d", layerNo, sectorNo); | |
516 | } | |
517 | else if(sectorNo==-1 && stackNo!=-1) { // plot a stack from a layer | |
518 | drawStr += ":SuperModule:Stack>>prof"; | |
519 | drawStr += rndNumber; | |
520 | drawStr += Form("(1,%f,%f,18,-0.5,17.5)", stackNo-0.5, stackNo+0.5); | |
521 | cutStr += Form("Layer==%d && Stack==%d", layerNo, stackNo); | |
522 | } | |
523 | else { // the layer, sector and stack are determined -> so plot a chamber | |
524 | drawStr += ":SuperModule:Stack>>prof"; | |
525 | drawStr += rndNumber; | |
526 | drawStr += Form("(1,%f,%f,1,%f,%f)", stackNo-0.5, stackNo+0.5, sectorNo-0.5, sectorNo+0.5); | |
527 | cutStr += Form("Layer==%d && SuperModule==%d && Stack==%d", layerNo, sectorNo, stackNo); | |
528 | } | |
529 | } | |
530 | ||
531 | ||
532 | if (cuts && cuts[0] != 0) { | |
533 | if (cutStr.Length() != 0) cutStr += "&& "; | |
534 | cutStr += "("; | |
535 | cutStr += cuts; | |
536 | cutStr += ")"; | |
537 | } | |
538 | drawStr.ReplaceAll(fAbbreviation, fAppendString); | |
539 | cutStr.ReplaceAll(fAbbreviation, fAppendString); | |
540 | if (writeDrawCommand) std::cout << "fTree->Draw(\"" << drawStr << "\", \"" << cutStr << "\", \"" << drawOptionsStr << "\");" << std::endl; | |
541 | Int_t returnValue = fTree->Draw(drawStr.Data(), cutStr.Data(), drawOptionsStr.Data()); | |
542 | TString profName("prof"); | |
543 | profName += rndNumber; | |
544 | TObject *obj = gDirectory->Get(profName.Data()); | |
545 | // set the names of the axes | |
546 | TH1 *histObj = (TH1*)obj; | |
547 | if(drawStr.Contains("Status") || drawStr.Contains("Gain") || drawStr.Contains("Noise") || | |
548 | drawStr.Contains("Vdrift") || drawStr.Contains("T0") || | |
549 | drawStr.Contains("gain") || drawStr.Contains("chiSquare")) { | |
550 | histObj->GetXaxis()->SetTitle("Row"); | |
551 | histObj->GetYaxis()->SetTitle("Column"); | |
552 | } | |
553 | else if(drawStr.Contains("SORandEOR") || | |
554 | drawStr.Contains("gsmSOR") || drawStr.Contains("gsmDelta") || | |
555 | drawStr.Contains("nimSOR") || drawStr.Contains("nimDelta") || | |
556 | drawStr.Contains("nevSOR") || drawStr.Contains("nevDelta") || | |
557 | drawStr.Contains("nptSOR") || drawStr.Contains("nptDelta")) { | |
558 | histObj->GetXaxis()->SetTitle("MCM Row"); | |
559 | histObj->GetYaxis()->SetTitle("MCM Column"); | |
560 | } | |
561 | else if(drawStr.Contains("Align")) { | |
562 | histObj->GetXaxis()->SetTitle("Stack"); | |
563 | histObj->GetYaxis()->SetTitle("Sector"); | |
564 | } | |
565 | ||
566 | if (obj && obj->InheritsFrom("TH1")) FormatHistoLabels((TH1*)obj); | |
567 | return returnValue; | |
568 | } | |
569 | ||
570 | //_____________________________________________________________________________ | |
571 | Int_t AliTRDCalibViewer::EasyDraw1D(const char* drawCommand, const char* sector, const char* cuts, const char* drawOptions, Bool_t writeDrawCommand) const { | |
572 | // | |
573 | // easy drawing of data, use '~' for abbreviation of '.fElements' | |
574 | // example: EasyDraw("CETmean~-CETmean_mean", "A", "(CETmean~-CETmean_mean)>0") | |
575 | // sector: sector-number - the specified sector will be drwawn | |
576 | // 'A'/'C' or 'a'/'c' - side A/C will be drawn | |
577 | // 'ALL' - whole TPC will be drawn, projected on one side | |
578 | // cuts: specifies cuts | |
579 | // drawOptions: draw options like 'same' | |
580 | // writeDrawCommand: write the command, that is passed to TTree::Draw | |
581 | // | |
582 | ||
583 | TString drawStr(drawCommand); | |
584 | ||
585 | TString sectorStr(sector); | |
586 | Int_t layerNo = -1; | |
587 | Int_t sectorNo = -1; | |
588 | Int_t stackNo = -1; | |
589 | GetLayerSectorStack(sectorStr, layerNo, sectorNo, stackNo); | |
590 | if(layerNo==-1) { | |
591 | Warning("EasyDraw", "The sector string must always contain the Layer number!"); | |
592 | return -1; | |
593 | } | |
594 | if(layerNo<0 || layerNo>5) { | |
595 | Warning("EasyDraw", "The Layer number must be in the range [0,5] !"); | |
596 | return -1; | |
597 | } | |
598 | if(sectorNo!=-1 && (sectorNo<0 || sectorNo>17)) { | |
599 | Warning("EasyDraw", "The Sector number must be in the range [0,17] !"); | |
600 | return -1; | |
601 | } | |
602 | if(stackNo!=-1 && (stackNo<0 || stackNo>4)) { | |
603 | Warning("EasyDraw", "The Stack number must be in the range [0,4] !"); | |
604 | return -1; | |
605 | } | |
606 | ||
607 | TString drawOptionsStr(drawOptions); | |
608 | TString cutStr(""); | |
609 | ||
610 | if(sectorNo==-1 && stackNo==-1) // plot the entire layer | |
611 | cutStr += Form("Layer==%d", layerNo); | |
612 | else if(sectorNo!=-1 && stackNo==-1) // plot a sector from a layer | |
613 | cutStr += Form("Layer==%d && SuperModule==%d", layerNo, sectorNo); | |
614 | else if(sectorNo==-1 && stackNo!=-1) // plot a stack from a layer | |
615 | cutStr += Form("Layer==%d && Stack==%d", layerNo, stackNo); | |
616 | else // the layer, sector and stack are determined -> so plot a chamber | |
617 | cutStr += Form("Layer==%d && SuperModule==%d && Stack==%d", layerNo, sectorNo, stackNo); | |
618 | ||
619 | if(cuts && cuts[0] != 0) { | |
620 | if (cutStr.Length() != 0) cutStr += "&& "; | |
621 | cutStr += "("; | |
622 | cutStr += cuts; | |
623 | cutStr += ")"; | |
624 | } | |
625 | ||
626 | drawStr.ReplaceAll(fAbbreviation, fAppendString); | |
627 | cutStr.ReplaceAll(fAbbreviation, fAppendString); | |
628 | if (writeDrawCommand) std::cout << "fTree->Draw(\"" << drawStr << "\", \"" << cutStr << "\", \"" << drawOptionsStr << "\");" << std::endl; | |
629 | Int_t returnValue = fTree->Draw(drawStr.Data(), cutStr.Data(), drawOptionsStr.Data()); | |
630 | if (returnValue == -1) return -1; | |
631 | ||
632 | TObject *obj = (gPad) ? gPad->GetPrimitive("htemp") : 0; | |
633 | if (!obj) obj = (TH1F*)gDirectory->Get("htemp"); | |
634 | if (!obj) obj = gPad->GetPrimitive("tempHist"); | |
635 | if (!obj) obj = (TH1F*)gDirectory->Get("tempHist"); | |
636 | if (!obj) obj = gPad->GetPrimitive("Graph"); | |
637 | if (!obj) obj = (TH1F*)gDirectory->Get("Graph"); | |
638 | if (obj && obj->InheritsFrom("TH1")) FormatHistoLabels((TH1*)obj); | |
639 | return returnValue; | |
640 | } | |
641 | ||
642 | //_____________________________________________________________________________ | |
643 | Int_t AliTRDCalibViewer::EasyDraw(const char* drawCommand, Int_t chamber, const char* cuts, const char* drawOptions, Bool_t writeDrawCommand) const { | |
644 | // | |
645 | // easy drawing of data, use '~' for abbreviation of '.fElements' | |
646 | // example: EasyDraw("CETmean~-CETmean_mean", 34, "(CETmean~-CETmean_mean)>0") | |
647 | // sector: sector-number - only the specified sector will be drwawn | |
648 | // cuts: specifies cuts | |
649 | // drawOptions: draw options like 'same' | |
650 | // writeDrawCommand: write the command, that is passed to TTree::Draw | |
651 | // | |
652 | if(chamber >= 0 && chamber < 540) { | |
653 | Int_t superModuleNo = chamber/30; | |
654 | Int_t stackNo = (chamber%30)/6; | |
655 | Int_t layerNo = (chamber%30)%6; | |
656 | char sectorChr[22]; | |
657 | snprintf(sectorChr,22, "Layer%iSector%iStack%i", layerNo, superModuleNo, stackNo); | |
658 | return EasyDraw(drawCommand, sectorChr, cuts, drawOptions, writeDrawCommand); | |
659 | } | |
660 | Error("EasyDraw","The TRD contains only chamber from 0 to 539"); | |
661 | return -1; | |
662 | } | |
663 | ||
664 | //_____________________________________________________________________________ | |
665 | Int_t AliTRDCalibViewer::EasyDraw1D(const char* drawCommand, Int_t chamber, const char* cuts, const char* drawOptions, Bool_t writeDrawCommand) const { | |
666 | // | |
667 | // easy drawing of data, use '~' for abbreviation of '.fElements' | |
668 | // example: EasyDraw("CETmean~-CETmean_mean", 34, "(CETmean~-CETmean_mean)>0") | |
669 | // sector: sector-number - the specified sector will be drwawn | |
670 | // cuts: specifies cuts | |
671 | // drawOptions: draw options like 'same' | |
672 | // writeDrawCommand: write the command, that is passed to TTree::Draw | |
673 | // | |
674 | ||
675 | if (chamber >= 0 && chamber < 539) { | |
676 | Int_t superModuleNo = chamber/30; | |
677 | Int_t stackNo = (chamber%30)/6; | |
678 | Int_t layerNo = (chamber%30)%6; | |
679 | char sectorChr[22]; | |
680 | snprintf(sectorChr,22, "Layer%iSector%iStack%i", layerNo, superModuleNo, stackNo); | |
681 | return EasyDraw1D(drawCommand, sectorChr, cuts, drawOptions, writeDrawCommand); | |
682 | } | |
683 | Error("EasyDraw1D","The TRD contains only chambers from 0 to 539"); | |
684 | return -1; | |
685 | } | |
686 | ||
687 | //_____________________________________________________________________________ | |
688 | Bool_t AliTRDCalibViewer::DumpOCDBtoTreeDetails(const Char_t* runListFilename, | |
689 | const Char_t* outFilename, | |
690 | Int_t firstRun, Int_t lastRun, | |
691 | const Char_t* storage, | |
692 | Int_t version, | |
693 | Int_t subVersion, | |
694 | Bool_t getCalibs, | |
695 | Bool_t getDCS, | |
696 | Bool_t getAlign) { | |
697 | // | |
698 | // Retrieve TRD OCDB information for a given run list/range | |
699 | // | |
700 | ||
701 | if(runListFilename[0]!='\0' && firstRun==-1 && lastRun==-1) { | |
702 | cout << "AliTRDCalibViewer::DumpOCDBtoTreeDetails(): You must provide at least a run range or an ascii filename with run numbers" | |
703 | << endl; | |
704 | return kFALSE; | |
705 | } | |
706 | // initialize the OCDB manager | |
707 | TString storageString = storage; | |
708 | if(storageString.Contains("alien://")) { | |
709 | TGrid::Connect("alien://"); | |
710 | } | |
711 | AliCDBManager *manager = AliCDBManager::Instance(); | |
712 | if(storage[0]!='\0') { | |
713 | manager->SetDefaultStorage(storage); | |
714 | } | |
715 | else { | |
716 | if(!manager->IsDefaultStorageSet()) { | |
717 | cout << "AliTRDCalibViewer::DumpOCDBtoTreeDetails(): Default OCDB storage not set!!" << endl; | |
718 | return kFALSE; | |
719 | } | |
720 | } | |
721 | manager->SetRun(1); | |
722 | ||
723 | // open the ascii file | |
724 | ifstream in; | |
725 | if(runListFilename[0]!='\0') | |
726 | in.open(runListFilename); | |
727 | ||
728 | // initialize the tree streamer | |
729 | if(outFilename[0]=='\0') outFilename = "trdDetails.root"; | |
730 | TString calibFilename = outFilename; | |
731 | ||
732 | TTreeSRedirector *treeStreamer = new TTreeSRedirector(calibFilename.Data()); | |
733 | ||
734 | Int_t currRun; | |
735 | if(runListFilename[0]=='\0' && firstRun!=-1 && lastRun!=-1) | |
736 | currRun = firstRun; | |
737 | ||
738 | TVectorD runs; | |
739 | ||
740 | // loop over runs | |
741 | while(1) { | |
742 | if(runListFilename[0]!='\0') { | |
743 | if(!(in>>currRun)) continue; | |
744 | if(currRun < (firstRun==-1 ? 0 : firstRun) || | |
745 | currRun > (lastRun==-1 ? 999999999 : lastRun)) | |
746 | continue; | |
747 | } | |
748 | else { | |
749 | if(currRun>lastRun) break; | |
750 | } | |
751 | cout << "run = " << currRun << endl; | |
752 | manager->SetRun(currRun); | |
753 | ||
754 | // Get GRP data. If there is no proper GRP object for this run than | |
755 | // this run is aborted | |
756 | AliCDBEntry *entry = manager->Get("GRP/GRP/Data"); | |
757 | AliGRPObject* grpObject = 0; | |
758 | if(entry) { | |
759 | entry->SetOwner(kFALSE); | |
760 | grpObject = dynamic_cast<AliGRPObject*>(entry->GetObject()); | |
761 | } | |
762 | else { | |
763 | currRun++; | |
764 | // continue; | |
765 | // return kFALSE; | |
766 | } | |
767 | if(!grpObject) | |
768 | cout << "No GRP info available for this run " << endl; | |
769 | ||
770 | time_t startTimeGRP = 0; | |
771 | TObjString runType(""); | |
772 | if(grpObject) { | |
773 | startTimeGRP = grpObject->GetTimeStart(); | |
774 | TTimeStamp start(grpObject->GetTimeStart()); | |
775 | TTimeStamp end(grpObject->GetTimeEnd()); | |
776 | cout << "Start time: " << start.GetDate()/10000 << "/" | |
777 | << (start.GetDate()/100)-(start.GetDate()/10000)*100 << "/" | |
778 | << start.GetDate()%100 << " " | |
779 | << start.GetTime()/10000 << ":" | |
780 | << (start.GetTime()/100)-(start.GetTime()/10000)*100 << ":" | |
781 | << start.GetTime()%100 << endl; | |
782 | cout << "End time: " << end.GetDate()/10000 << "/" | |
783 | << (end.GetDate()/100)-(end.GetDate()/10000)*100 << "/" | |
784 | << end.GetDate()%100 << " " | |
785 | << end.GetTime()/10000 << ":" | |
786 | << (end.GetTime()/100)-(end.GetTime()/10000)*100 << ":" | |
787 | << end.GetTime()%100 << endl; | |
788 | cout << "Run type = " << grpObject->GetRunType().Data() << endl; | |
789 | runType = grpObject->GetRunType().Data(); | |
790 | } | |
791 | ||
792 | // gain | |
793 | AliTRDCalDet *chamberGainFactor = 0; | |
794 | if(getCalibs) { | |
795 | entry = manager->Get("TRD/Calib/ChamberGainFactor", currRun, version, subVersion); | |
796 | if(entry) { | |
797 | entry->SetOwner(kFALSE); | |
798 | chamberGainFactor = (AliTRDCalDet*)entry->GetObject(); | |
799 | } | |
800 | } | |
801 | AliTRDCalPad *padGainFactor = 0; | |
802 | if(getCalibs) { | |
803 | entry = manager->Get("TRD/Calib/LocalGainFactor", currRun, version, subVersion); | |
804 | if(entry) { | |
805 | entry->SetOwner(kFALSE); | |
806 | padGainFactor = (AliTRDCalPad*)entry->GetObject(); | |
807 | } | |
808 | } | |
809 | Double_t runMeanGain, runRMSGain; | |
810 | TVectorD chamberMeanGain(AliTRDcalibDB::kNdet); | |
811 | TVectorD chamberRMSGain(AliTRDcalibDB::kNdet); | |
812 | TVectorD smMeanGain(AliTRDcalibDB::kNsector); | |
813 | TVectorD smRMSGain(AliTRDcalibDB::kNsector); | |
814 | for(Int_t iNdet=0; iNdet<AliTRDcalibDB::kNdet; iNdet++) {chamberMeanGain[iNdet] = 0.0; chamberRMSGain[iNdet] = 0.0;} | |
815 | for(Int_t iSm=0; iSm<AliTRDcalibDB::kNsector; iSm++) {smMeanGain[iSm] = 0.0; smRMSGain[iSm] = 0.0;} | |
816 | TString parName("Gain"); | |
817 | if(getCalibs) | |
818 | ProcessTRDCalibArray(chamberGainFactor, padGainFactor, | |
819 | parName, | |
820 | runMeanGain, runRMSGain, | |
821 | chamberMeanGain, chamberRMSGain, | |
822 | smMeanGain, smRMSGain); | |
823 | ||
824 | // noise/pedestals | |
825 | AliTRDCalDet *chamberNoise = 0; | |
826 | if(getCalibs) { | |
827 | entry = manager->Get("TRD/Calib/DetNoise", currRun, version, subVersion); | |
828 | if(entry) { | |
829 | entry->SetOwner(kFALSE); | |
830 | chamberNoise = (AliTRDCalDet*)entry->GetObject(); | |
831 | } | |
832 | } | |
833 | AliTRDCalPad *padNoise = 0; | |
834 | if(getCalibs) { | |
835 | entry = manager->Get("TRD/Calib/PadNoise", currRun, version, subVersion); | |
836 | if(entry) { | |
837 | entry->SetOwner(kFALSE); | |
838 | padNoise = (AliTRDCalPad*)entry->GetObject(); | |
839 | } | |
840 | } | |
841 | Double_t runMeanNoise, runRMSNoise; | |
842 | TVectorD chamberMeanNoise(AliTRDcalibDB::kNdet); | |
843 | TVectorD chamberRMSNoise(AliTRDcalibDB::kNdet); | |
844 | TVectorD smMeanNoise(AliTRDcalibDB::kNsector); | |
845 | TVectorD smRMSNoise(AliTRDcalibDB::kNsector); | |
846 | for(Int_t iNdet=0; iNdet<AliTRDcalibDB::kNdet; iNdet++) {chamberMeanNoise[iNdet] = 0.0; chamberRMSNoise[iNdet] = 0.0;} | |
847 | for(Int_t iSm=0; iSm<AliTRDcalibDB::kNsector; iSm++) {smMeanNoise[iSm] = 0.0; smRMSNoise[iSm] = 0.0;} | |
848 | parName = "Noise"; | |
849 | if(getCalibs) | |
850 | ProcessTRDCalibArray(chamberNoise, padNoise, | |
851 | parName, | |
852 | runMeanNoise, runRMSNoise, | |
853 | chamberMeanNoise, chamberRMSNoise, | |
854 | smMeanNoise, smRMSNoise); | |
855 | ||
856 | // vdrift | |
857 | AliTRDCalDet *chamberVdrift = 0; | |
858 | if(getCalibs) { | |
859 | entry = manager->Get("TRD/Calib/ChamberVdrift", currRun, version, subVersion); | |
860 | if(entry) { | |
861 | entry->SetOwner(kFALSE); | |
862 | chamberVdrift = (AliTRDCalDet*)entry->GetObject(); | |
863 | } | |
864 | } | |
865 | AliTRDCalPad *padVdrift = 0; | |
866 | if(getCalibs) { | |
867 | entry = manager->Get("TRD/Calib/LocalVdrift", currRun, version, subVersion); | |
868 | if(entry) { | |
869 | entry->SetOwner(kFALSE); | |
870 | padVdrift = (AliTRDCalPad*)entry->GetObject(); | |
871 | } | |
872 | } | |
873 | Double_t runMeanVdrift, runRMSVdrift; | |
874 | TVectorD chamberMeanVdrift(AliTRDcalibDB::kNdet); | |
875 | TVectorD chamberRMSVdrift(AliTRDcalibDB::kNdet); | |
876 | TVectorD smMeanVdrift(AliTRDcalibDB::kNsector); | |
877 | TVectorD smRMSVdrift(AliTRDcalibDB::kNsector); | |
878 | for(Int_t iNdet=0; iNdet<AliTRDcalibDB::kNdet; iNdet++) {chamberMeanVdrift[iNdet] = 0.0; chamberRMSVdrift[iNdet] = 0.0;} | |
879 | for(Int_t iSm=0; iSm<AliTRDcalibDB::kNsector; iSm++) {smMeanVdrift[iSm] = 0.0; smRMSVdrift[iSm] = 0.0;} | |
880 | parName = "Vdrift"; | |
881 | if(getCalibs) | |
882 | ProcessTRDCalibArray(chamberVdrift, padVdrift, | |
883 | parName, | |
884 | runMeanVdrift, runRMSVdrift, | |
885 | chamberMeanVdrift, chamberRMSVdrift, | |
886 | smMeanVdrift, smRMSVdrift); | |
887 | ||
888 | // T0 | |
889 | AliTRDCalDet *chamberT0 = 0; | |
890 | if(getCalibs) { | |
891 | entry = manager->Get("TRD/Calib/ChamberT0", currRun, version, subVersion); | |
892 | if(entry) { | |
893 | entry->SetOwner(kFALSE); | |
894 | chamberT0 = (AliTRDCalDet*)entry->GetObject(); | |
895 | } | |
896 | } | |
897 | AliTRDCalPad *padT0 = 0; | |
898 | if(getCalibs) { | |
899 | entry = manager->Get("TRD/Calib/LocalT0", currRun, version, subVersion); | |
900 | if(entry) { | |
901 | entry->SetOwner(kFALSE); | |
902 | padT0 = (AliTRDCalPad*)entry->GetObject(); | |
903 | } | |
904 | } | |
905 | Double_t runMeanT0, runRMST0; | |
906 | TVectorD chamberMeanT0(AliTRDcalibDB::kNdet); | |
907 | TVectorD chamberRMST0(AliTRDcalibDB::kNdet); | |
908 | TVectorD smMeanT0(AliTRDcalibDB::kNsector); | |
909 | TVectorD smRMST0(AliTRDcalibDB::kNsector); | |
910 | for(Int_t iNdet=0; iNdet<AliTRDcalibDB::kNdet; iNdet++) {chamberMeanT0[iNdet] = 0.0; chamberRMST0[iNdet] = 0.0;} | |
911 | for(Int_t iSm=0; iSm<AliTRDcalibDB::kNsector; iSm++) {smMeanT0[iSm] = 0.0; smRMST0[iSm] = 0.0;} | |
912 | parName = "T0"; | |
913 | if(getCalibs) | |
914 | ProcessTRDCalibArray(chamberT0, padT0, | |
915 | parName, | |
916 | runMeanT0, runRMST0, | |
917 | chamberMeanT0, chamberRMST0, | |
918 | smMeanT0, smRMST0); | |
919 | ||
920 | // status | |
921 | AliTRDCalChamberStatus* chamberStatus = 0; | |
922 | if(getCalibs) { | |
923 | entry = manager->Get("TRD/Calib/ChamberStatus", currRun, version, subVersion); | |
924 | if(entry) { | |
925 | entry->SetOwner(kFALSE); | |
926 | chamberStatus = (AliTRDCalChamberStatus*)entry->GetObject(); | |
927 | } | |
928 | } | |
929 | AliTRDCalPadStatus *padStatus = 0; | |
930 | if(getCalibs) { | |
931 | entry = manager->Get("TRD/Calib/PadStatus", currRun, version, subVersion); | |
932 | if(entry) { | |
933 | entry->SetOwner(kFALSE); | |
934 | padStatus = (AliTRDCalPadStatus*)entry->GetObject(); | |
935 | } | |
936 | } | |
937 | ||
938 | // DCS FEE information | |
939 | TObjArray *dcsArray = 0; | |
940 | if(getDCS) { | |
941 | entry = manager->Get("TRD/Calib/DCS"); | |
942 | if(entry) { | |
943 | entry->SetOwner(kTRUE); | |
944 | dcsArray = (TObjArray*)entry->GetObject(); | |
945 | } | |
946 | } | |
947 | AliTRDCalDCSv2 *dcsSOR = 0; | |
948 | AliTRDCalDCSv2 *dcsEOR = 0; | |
949 | if(getDCS && dcsArray) { | |
950 | dcsSOR = (AliTRDCalDCSv2*)dcsArray->At(0); | |
951 | dcsEOR = (AliTRDCalDCSv2*)dcsArray->At(1); | |
952 | } | |
953 | ||
954 | // Alignment information | |
955 | // get the geometry from OCDB | |
956 | TGeoManager *geoMan = 0x0; | |
957 | if(getAlign) { | |
958 | entry=manager->Get("GRP/Geometry/Data"); | |
959 | if(entry) | |
960 | geoMan=(TGeoManager*)entry->GetObject(); | |
961 | else | |
962 | cout << "Cannot get an entry for the geometry storage" << endl; | |
963 | } | |
964 | // get the alignment from OCDB | |
965 | AliTRDalignment *alignMan=0; | |
966 | if(getAlign && geoMan) { | |
967 | entry=manager->Get("TRD/Align/Data", currRun, version, subVersion); | |
968 | if(entry) { | |
969 | alignMan = new AliTRDalignment(); | |
970 | cout << "storage for alignment = " << manager->GetDefaultStorage()->GetURI().Data() << endl; | |
971 | alignMan->ReadDB(manager->GetDefaultStorage()->GetURI().Data(), "TRD/Align/Data", currRun, version, subVersion); | |
972 | } | |
973 | else { | |
974 | cout << "Cannot get an entry for the alignment info" << endl; | |
975 | } | |
976 | } | |
977 | ||
978 | Int_t kSuperModuleStatus[18] = {1, 1, 0, 0, 0, 0, // super module status (1- installed, 0- not installed) | |
979 | 0, 1, 1, 1, 1, 0, | |
980 | 0, 0, 0, 0, 0, 1}; | |
981 | Int_t kNRows[ 5] = {16, 16, 12, 16, 16}; // number of pad rows in the chambers from each of the 5 stacks | |
982 | Int_t kNCols = 144; // number of pad columns in the chambers from each of the 18 supermodules | |
983 | Int_t kROB[5] = {8, 8, 6, 8, 8}; // number of read out boards(ROB) per chamber (6 in stack 2 and 8 in the rest) | |
984 | Int_t kMCM = 16; // number of MCMs per ROB | |
985 | for(Short_t iLayer=0; iLayer<AliTRDgeometry::kNlayer; iLayer++) { // loop over layers | |
986 | for(Short_t iSector=0; iSector<AliTRDgeometry::kNsector; iSector++) { // loop over supermodules | |
987 | if(kSuperModuleStatus[iSector]==0) | |
988 | continue; | |
989 | Double_t alignSMPars[6]; | |
990 | for(Int_t ipar=0; ipar<6; ipar++) alignSMPars[ipar]=0.0; | |
991 | if(getAlign && alignMan) | |
992 | alignMan->GetSm(iSector, alignSMPars); | |
993 | for(Short_t iStack=0; iStack<AliTRDgeometry::kNstack; iStack++) { // loop over stacks | |
994 | Short_t chamberNo = AliTRDgeometry::GetDetector(iLayer, iStack, iSector); | |
995 | AliTRDCalROC *gainROC = 0; | |
996 | if(padGainFactor) gainROC = padGainFactor->GetCalROC(chamberNo); | |
997 | AliTRDCalROC *noiseROC = 0; | |
998 | if(padNoise) noiseROC = padNoise->GetCalROC(chamberNo); | |
999 | AliTRDCalROC *vdriftROC = 0; | |
1000 | if(padVdrift) vdriftROC = padVdrift->GetCalROC(chamberNo); | |
1001 | AliTRDCalROC *t0ROC = 0; | |
1002 | if(t0ROC) t0ROC = padT0->GetCalROC(chamberNo); | |
1003 | AliTRDCalSingleChamberStatus *statusROC = 0; | |
1004 | if(padStatus) statusROC = padStatus->GetCalROC(chamberNo); | |
1005 | TVectorD channelVector(kNRows[iStack]*kNCols); | |
1006 | TVectorD rowVector(kNRows[iStack]*kNCols); | |
1007 | TVectorD colVector(kNRows[iStack]*kNCols); | |
1008 | TVectorD statusVector(kNRows[iStack]*kNCols); | |
1009 | TVectorD gainVector(kNRows[iStack]*kNCols); | |
1010 | TVectorD noiseVector(kNRows[iStack]*kNCols); | |
1011 | TVectorD vdriftVector(kNRows[iStack]*kNCols); | |
1012 | TVectorD t0Vector(kNRows[iStack]*kNCols); | |
1013 | TVectorD padSuperRowVector(kNRows[iStack]*kNCols); | |
1014 | TVectorD padSuperColumnVector(kNRows[iStack]*kNCols); | |
1015 | for(Int_t ipar=0; ipar<kNRows[iStack]*kNCols; ipar++) { | |
1016 | channelVector[ipar] = 0; rowVector[ipar] = 0; colVector[ipar] = 0; | |
1017 | statusVector[ipar] = 0; gainVector[ipar] = 0; noiseVector[ipar] = 0; | |
1018 | vdriftVector[ipar] = 0; t0Vector[ipar] = 0; padSuperRowVector[ipar] = 0; | |
1019 | padSuperColumnVector[ipar] = 0; | |
1020 | } | |
1021 | Int_t index = 0; | |
1022 | if(getCalibs) { | |
1023 | for(Short_t iRow=0; iRow<kNRows[iStack]; iRow++) { // loop over pad rows | |
1024 | for(Short_t iCol=0; iCol<kNCols; iCol++) { // loop over pad columns | |
1025 | Short_t padSuperRow = iRow; | |
1026 | for(Int_t i=0; i<iStack; i++) padSuperRow = padSuperRow + kNRows[i]; | |
1027 | padSuperRowVector[index] = padSuperRow; | |
1028 | Short_t padSuperColumn = iCol; | |
1029 | for(Int_t i=0; i<iSector; i++) padSuperColumn = padSuperColumn + kNCols; | |
1030 | padSuperColumnVector[index] = padSuperColumn; | |
1031 | Short_t channelNo = -1; | |
1032 | Float_t gain = -99.; | |
1033 | if(gainROC && chamberGainFactor) { | |
1034 | channelNo = gainROC->GetChannel(iCol, iRow); | |
1035 | gain = chamberGainFactor->GetValue(chamberNo) * gainROC->GetValue(iCol, iRow); | |
1036 | } | |
1037 | Float_t noise = -99.; | |
1038 | if(noiseROC && chamberNoise) | |
1039 | noise = chamberNoise->GetValue(chamberNo) * noiseROC->GetValue(iCol, iRow); | |
1040 | Float_t vdrift = -99.; | |
1041 | if(vdriftROC && chamberVdrift) | |
1042 | vdrift = chamberVdrift->GetValue(chamberNo) * vdriftROC->GetValue(iCol, iRow); | |
1043 | Float_t t0 = -99.; | |
1044 | if(t0ROC && chamberT0) | |
1045 | t0 = chamberT0->GetValue(chamberNo) + t0ROC->GetValue(iCol, iRow); | |
1046 | Int_t status = -99; | |
1047 | if(statusROC) | |
1048 | status = statusROC->GetStatus(iCol, iRow); | |
1049 | channelVector[index] = channelNo; | |
1050 | rowVector[index] = iRow; | |
1051 | colVector[index] = iCol; | |
1052 | statusVector[index] = status; | |
1053 | gainVector[index] = gain; | |
1054 | noiseVector[index] = noise; | |
1055 | vdriftVector[index] = vdrift; | |
1056 | t0Vector[index] = t0; | |
1057 | index++; | |
1058 | } // end loop over pad columns | |
1059 | } // end loop over pad rows | |
1060 | } // end if(getCalibs) | |
1061 | ||
1062 | // get the dcs information | |
1063 | AliTRDCalDCSFEEv2 *dcsfeeSOR = 0; | |
1064 | AliTRDCalDCSFEEv2 *dcsfeeEOR = 0; | |
1065 | if(getDCS) { | |
1066 | if(dcsSOR) dcsfeeSOR = dcsSOR->GetCalDCSFEEObj(chamberNo); | |
1067 | if(dcsEOR) dcsfeeEOR = dcsEOR->GetCalDCSFEEObj(chamberNo); | |
1068 | } | |
1069 | ||
1070 | Bool_t sorAndEor = kFALSE; | |
1071 | if(getDCS && dcsfeeSOR && dcsfeeEOR) sorAndEor = kTRUE; | |
1072 | if(getDCS && !dcsfeeSOR && dcsfeeEOR) dcsfeeSOR = dcsfeeEOR; | |
1073 | TVectorD robVector(kROB[iStack]*kMCM); | |
1074 | TVectorD mcmVector(kROB[iStack]*kMCM); | |
1075 | TVectorD sorandeorVector(kROB[iStack]*kMCM); | |
1076 | TVectorD gsmSorVector(kROB[iStack]*kMCM); | |
1077 | TVectorD gsmDeltaVector(kROB[iStack]*kMCM); | |
1078 | TVectorD nimSorVector(kROB[iStack]*kMCM); | |
1079 | TVectorD nimDeltaVector(kROB[iStack]*kMCM); | |
1080 | TVectorD nevSorVector(kROB[iStack]*kMCM); | |
1081 | TVectorD nevDeltaVector(kROB[iStack]*kMCM); | |
1082 | TVectorD nptSorVector(kROB[iStack]*kMCM); | |
1083 | TVectorD nptDeltaVector(kROB[iStack]*kMCM); | |
1084 | TVectorD mcmSuperRowVector(kROB[iStack]*kMCM); | |
1085 | TVectorD mcmSuperColumnVector(kROB[iStack]*kMCM); | |
1086 | for(Int_t ipar=0; ipar<kROB[iStack]*kMCM; ipar++) { | |
1087 | robVector[ipar] = 0; mcmVector[ipar] = 0; sorandeorVector[ipar] = 0; | |
1088 | gsmSorVector[ipar] = 0; gsmDeltaVector[ipar] = 0; nimSorVector[ipar] = 0; | |
1089 | nimDeltaVector[ipar] = 0; nevSorVector[ipar] = 0; nevDeltaVector[ipar] = 0; | |
1090 | nptSorVector[ipar] = 0; nptDeltaVector[ipar] = 0; mcmSuperRowVector[ipar] = 0; | |
1091 | mcmSuperColumnVector[ipar] = 0; | |
1092 | } | |
1093 | ||
1094 | Int_t robsRowDirection = kNRows[iStack]/4; // 4 or 3 ROBs per chamber in row direction | |
1095 | Int_t index1 = 0; | |
1096 | if(getDCS && (dcsfeeSOR || dcsfeeEOR) && dcsfeeSOR->GetStatusBit()==0) { | |
1097 | for(Int_t iROB=0; iROB<kROB[iStack]; iROB++) { // loop over ROBs | |
1098 | for(Int_t iMCM=0; iMCM<kMCM; iMCM++) { // loop over MCMs | |
1099 | Short_t superRowMCM = iMCM%4; // 4 MCMs per ROB in row direction | |
1100 | superRowMCM += 4*(iROB%robsRowDirection); // now we have the row of this MCM inside one chamber | |
1101 | for(Int_t kk=0; kk<iStack; kk++) superRowMCM += kNRows[kk]; // add number of rows in previous stacks | |
1102 | Short_t superColumnMCM = iMCM/4; // 4 MCMs per ROB in column direction | |
1103 | superColumnMCM += 4*(iROB/robsRowDirection); // should yield 0 or 1 (2 ROBs per chamber in col direction) | |
1104 | superColumnMCM += iSector*8; | |
1105 | mcmSuperRowVector[index1] = superRowMCM; | |
1106 | mcmSuperColumnVector[index1] = superColumnMCM; | |
1107 | Int_t gsm = dcsfeeSOR->GetMCMGlobalState(iROB, iMCM); | |
1108 | Int_t nim = dcsfeeSOR->GetMCMStateNI(iROB, iMCM); | |
1109 | Int_t nev = dcsfeeSOR->GetMCMEventCnt(iROB, iMCM); | |
1110 | Int_t npt = dcsfeeSOR->GetMCMPtCnt(iROB, iMCM); | |
1111 | Int_t dgsm = -100000; | |
1112 | Int_t dnim = -100000; | |
1113 | Int_t dnev = -100000; | |
1114 | Int_t dnpt = -100000; | |
1115 | if(sorAndEor) { | |
1116 | dgsm = gsm - dcsfeeEOR->GetMCMGlobalState(iROB, iMCM); | |
1117 | dnim = nim - dcsfeeEOR->GetMCMStateNI(iROB, iMCM); | |
1118 | dnev = nev - dcsfeeEOR->GetMCMEventCnt(iROB, iMCM); | |
1119 | dnpt = npt - dcsfeeEOR->GetMCMPtCnt(iROB, iMCM); | |
1120 | if(gsm==-1 && dgsm==0) dgsm = -100000; | |
1121 | if(nim==-1 && dnim==0) dnim = -100000; | |
1122 | if(nev==-1 && dnev==0) dnev = -100000; | |
1123 | if(npt==-1 && dnpt==0) dnpt = -100000; | |
1124 | } | |
1125 | robVector[index1] = iROB; | |
1126 | mcmVector[index1] = iMCM; | |
1127 | sorandeorVector[index1] = sorAndEor; | |
1128 | gsmSorVector[index1] = gsm; | |
1129 | gsmDeltaVector[index1] = dgsm; | |
1130 | nimSorVector[index1] = nim; | |
1131 | nimDeltaVector[index1] = dnim; | |
1132 | nevSorVector[index1] = nev; | |
1133 | nevDeltaVector[index1] = dnev; | |
1134 | nptSorVector[index1] = npt; | |
1135 | nptDeltaVector[index1] = dnpt; | |
1136 | index1++; | |
1137 | } // end loop over MCMs | |
1138 | } // end loop over ROBs | |
1139 | } // end if(getDCS ...) | |
1140 | ||
1141 | Double_t alignChamberPars[6]; | |
1142 | for(Int_t ipar=0; ipar<6; ipar++) alignChamberPars[ipar]=0; | |
1143 | if(getAlign && alignMan) | |
1144 | alignMan->GetCh(chamberNo, alignChamberPars); | |
1145 | ||
1146 | (*treeStreamer)<< "TRDcalibDetails" | |
1147 | << "run=" << currRun | |
1148 | << "SuperModule=" << iSector | |
1149 | << "Stack=" << iStack | |
1150 | << "Layer=" << iLayer | |
1151 | << "Chamber=" << chamberNo; | |
1152 | if(getAlign) | |
1153 | (*treeStreamer)<< "TRDcalibDetails" | |
1154 | << "Align_SM_ShiftRphi=" << alignSMPars[0] | |
1155 | << "Align_SM_ShiftZ=" << alignSMPars[1] | |
1156 | << "Align_SM_ShiftR=" << alignSMPars[2] | |
1157 | << "Align_SM_RotRphi=" << alignSMPars[3] | |
1158 | << "Align_SM_RotZ=" << alignSMPars[4] | |
1159 | << "Align_SM_RotR=" << alignSMPars[5] | |
1160 | << "Align_Ch_ShiftRphi=" << alignChamberPars[0] | |
1161 | << "Align_Ch_ShiftZ=" << alignChamberPars[1] | |
1162 | << "Align_Ch_ShiftR=" << alignChamberPars[2] | |
1163 | << "Align_Ch_RotRphi=" << alignChamberPars[3] | |
1164 | << "Align_Ch_RotZ=" << alignChamberPars[4] | |
1165 | << "Align_Ch_RotR=" << alignChamberPars[5]; | |
1166 | if(getCalibs) | |
1167 | (*treeStreamer)<< "TRDcalibDetails" | |
1168 | << "Gain_Mean_Run=" << runMeanGain | |
1169 | << "Gain_RMS_Run=" << runRMSGain | |
1170 | << "Gain_Mean_SuperModule=" << smMeanGain[iSector] | |
1171 | << "Gain_RMS_SuperModule=" << smRMSGain[iSector] | |
1172 | << "Gain_Mean_Chamber=" << chamberMeanGain[chamberNo] | |
1173 | << "Gain_RMS_Chamber=" << chamberRMSGain[chamberNo] | |
1174 | << "Noise_Mean_Run=" << runMeanNoise | |
1175 | << "Noise_RMS_Run=" << runRMSNoise | |
1176 | << "Noise_Mean_SuperModule=" << smMeanNoise[iSector] | |
1177 | << "Noise_RMS_SuperModule=" << smRMSNoise[iSector] | |
1178 | << "Noise_Mean_Chamber=" << chamberMeanNoise[chamberNo] | |
1179 | << "Noise_RMS_Chamber=" << chamberRMSNoise[chamberNo] | |
1180 | << "Vdrift_Mean_Run=" << runMeanVdrift | |
1181 | << "Vdrift_RMS_Run=" << runRMSVdrift | |
1182 | << "Vdrift_Mean_SuperModule=" << smMeanVdrift[iSector] | |
1183 | << "Vdrift_RMS_SuperModule=" << smRMSVdrift[iSector] | |
1184 | << "Vdrift_Mean_Chamber=" << chamberMeanVdrift[chamberNo] | |
1185 | << "Vdrift_RMS_Chamber=" << chamberRMSVdrift[chamberNo] | |
1186 | << "T0_Mean_Run=" << runMeanT0 | |
1187 | << "T0_RMS_Run=" << runRMST0 | |
1188 | << "T0_Mean_SuperModule=" << smMeanT0[iSector] | |
1189 | << "T0_RMS_SuperModule=" << smRMST0[iSector] | |
1190 | << "T0_Mean_Chamber=" << chamberMeanT0[chamberNo] | |
1191 | << "T0_RMS_Chamber=" << chamberRMST0[chamberNo] | |
1192 | << "Channel.=" << &channelVector | |
1193 | << "Row.=" << &rowVector | |
1194 | << "Column.=" << &colVector | |
1195 | << "PadSuperRow.=" << &padSuperRowVector | |
1196 | << "PadSuperColumn.=" << &padSuperColumnVector | |
1197 | << "Status.=" << &statusVector | |
1198 | << "Gain.=" << &gainVector | |
1199 | << "Noise.=" << &noiseVector | |
1200 | << "Vdrift.=" << &vdriftVector | |
1201 | << "T0.=" << &t0Vector; | |
1202 | if(getDCS) | |
1203 | (*treeStreamer)<< "TRDcalibDetails" | |
1204 | << "ROB.=" << &robVector | |
1205 | << "MCM.=" << &mcmVector | |
1206 | << "MCMSuperRow.=" << &mcmSuperRowVector | |
1207 | << "MCMSuperColumn.=" << &mcmSuperColumnVector | |
1208 | << "SORandEOR.=" << &sorandeorVector | |
1209 | << "gsmSOR.=" << &gsmSorVector | |
1210 | << "gsmDelta.=" << &gsmDeltaVector | |
1211 | << "nimSOR.=" << &nimSorVector | |
1212 | << "nimDelta.=" << &nimDeltaVector | |
1213 | << "nevSOR.=" << &nevSorVector | |
1214 | << "nevDelta.=" << &nevDeltaVector | |
1215 | << "nptSOR.=" << &nptSorVector | |
1216 | << "nptDelta.=" << &nptDeltaVector; | |
1217 | (*treeStreamer)<< "TRDcalibDetails" | |
1218 | << "\n"; | |
1219 | } // end loop over stacks | |
1220 | } // end loop over supermodules | |
1221 | } // end loop over layers | |
1222 | ||
1223 | // add the run number to the list of runs | |
1224 | runs.ResizeTo(runs.GetNoElements()+1); | |
1225 | runs[runs.GetNoElements()-1] = currRun; | |
1226 | ||
1227 | // do cleaning | |
1228 | if(chamberGainFactor) delete chamberGainFactor; | |
1229 | if(padGainFactor) delete padGainFactor; | |
1230 | if(chamberNoise) delete chamberNoise; | |
1231 | if(padNoise) delete padNoise; | |
1232 | if(chamberVdrift) delete chamberVdrift; | |
1233 | if(padVdrift) delete padVdrift; | |
1234 | if(chamberT0) delete chamberT0; | |
1235 | if(padT0) delete padT0; | |
1236 | if(chamberStatus) delete chamberStatus; | |
1237 | if(padStatus) delete padStatus; | |
1238 | ||
1239 | // check if we still have run numbers in the file or provided range | |
1240 | if(runListFilename[0]=='\0' && firstRun!=-1 && lastRun!=-1) { | |
1241 | currRun++; | |
1242 | if(currRun>lastRun) break; | |
1243 | } | |
1244 | if(runListFilename[0]!='\0' && in.eof()) | |
1245 | break; | |
1246 | } // end loop over runs | |
1247 | ||
1248 | treeStreamer->GetFile()->cd(); | |
1249 | runs.Write("runs"); | |
1250 | delete treeStreamer; | |
1251 | return kTRUE; | |
1252 | // delete treeStreamerDCS; | |
1253 | } | |
1254 | ||
1255 | //_________________________________________________________________________ | |
1256 | void AliTRDCalibViewer::DumpCalibToTree(const Char_t* inFilename, const Char_t* outFilename) | |
1257 | { | |
1258 | // | |
1259 | // extract info from CalPad objects and dump them into a tree to be viewed | |
1260 | // | |
1261 | TTreeSRedirector *treeStreamer = new TTreeSRedirector(outFilename); | |
1262 | //open file and retrieve list of calPad objects | |
1263 | TFile f(inFilename); | |
1264 | TList *l=(TList*)f.GetListOfKeys(); | |
1265 | ||
1266 | TObjArray arrCalPads; | |
1267 | TObjArray arrSMmean; | |
1268 | TObjArray arrSMrms; | |
1269 | arrCalPads.SetOwner(); | |
1270 | arrSMmean.SetOwner(); | |
1271 | arrSMrms.SetOwner(); | |
1272 | ||
1273 | TIter next(l); | |
1274 | TKey *k=0x0; | |
1275 | while ( (k=(TKey*)next()) ){ | |
1276 | AliTRDCalPad *pad=dynamic_cast<AliTRDCalPad*>(k->ReadObj()); | |
1277 | if (!pad) continue; | |
1278 | arrCalPads.Add(pad); | |
1279 | ||
1280 | TVectorD *smMean=new TVectorD(AliTRDcalibDB::kNsector); | |
1281 | TVectorD *smRMS=new TVectorD(AliTRDcalibDB::kNsector); | |
1282 | ||
1283 | arrSMmean.Add(smMean); | |
1284 | arrSMrms.Add(smRMS); | |
1285 | ||
1286 | ProcessTRDCalibArray(pad, *smMean, *smRMS); | |
1287 | } | |
1288 | ||
1289 | Int_t kSuperModuleStatus[18] = {1, 1, 0, 0, 0, 0, // super module status (1- installed, 0- not installed) | |
1290 | 0, 1, 1, 1, 1, 0, | |
1291 | 0, 0, 0, 0, 0, 1}; | |
1292 | ||
1293 | AliTRDgeometry trdGeom; | |
1294 | Int_t kNRows[5] = {16, 16, 12, 16, 16}; // number of pad rows in the chambers from each of the 5 stacks | |
1295 | ||
1296 | for(Short_t iLayer=0; iLayer<AliTRDgeometry::kNlayer; iLayer++) { // loop over layers | |
1297 | for(Short_t iSM=0; iSM<AliTRDgeometry::kNsector; iSM++) { // loop over supermodules | |
1298 | if(kSuperModuleStatus[iSM]==0) | |
1299 | continue; | |
1300 | ||
1301 | for(Short_t iStack=0; iStack<AliTRDgeometry::kNstack; iStack++) { // loop over stacks | |
1302 | AliTRDpadPlane &plane=*trdGeom.GetPadPlane(iLayer, iStack); | |
1303 | ||
1304 | Short_t chamberNo = AliTRDgeometry::GetDetector(iLayer, iStack, iSM); | |
1305 | const Int_t nrows=plane.GetNrows(); | |
1306 | const Int_t ncols=plane.GetNcols(); | |
1307 | const Int_t nchannels=nrows*ncols; | |
1308 | // printf("chamberNo: %d (%03d-%03d-%03d)\n", chamberNo,nrows,ncols,nchannels); | |
1309 | ||
1310 | TVectorD channelVector(nchannels); | |
1311 | TVectorD rowVector(nchannels); | |
1312 | TVectorD colVector(nchannels); | |
1313 | ||
1314 | TVectorD gxVector(nchannels); | |
1315 | TVectorD gyVector(nchannels); | |
1316 | TVectorD gzVector(nchannels); | |
1317 | ||
1318 | TVectorD padSuperRowVector(nchannels); | |
1319 | TVectorD padSuperColumnVector(nchannels); | |
1320 | ||
1321 | Int_t index = 0; | |
1322 | for(Short_t iRow=0; iRow<nrows; iRow++) { // loop over pad rows | |
1323 | for(Short_t iCol=0; iCol<ncols; iCol++) { // loop over pad columns | |
1324 | Short_t padSuperRow = iRow; | |
1325 | for(Int_t i=0; i<iStack; i++) padSuperRow = padSuperRow + kNRows[i]; | |
1326 | padSuperRowVector.GetMatrixArray()[index] = padSuperRow; | |
1327 | ||
1328 | Short_t padSuperColumn = iCol; | |
1329 | for(Int_t i=0; i<iSM; i++) padSuperColumn = padSuperColumn + ncols; | |
1330 | padSuperColumnVector.GetMatrixArray()[index] = padSuperColumn; | |
1331 | ||
1332 | rowVector.GetMatrixArray()[index] = iRow; | |
1333 | colVector.GetMatrixArray()[index] = iCol; | |
1334 | ||
1335 | index++; | |
1336 | } // end loop over pad columns | |
1337 | } // end loop over pad rows | |
1338 | ||
1339 | (*treeStreamer)<< "TRDcalibDetails" | |
1340 | << "SuperModule=" << iSM | |
1341 | << "Stack=" << iStack | |
1342 | << "Layer=" << iLayer | |
1343 | << "Chamber=" << chamberNo | |
1344 | //geographical information | |
1345 | << "Channel.=" << &channelVector | |
1346 | << "Row.=" << &rowVector | |
1347 | << "Column.=" << &colVector | |
1348 | << "PadSuperRow.=" << &padSuperRowVector | |
1349 | << "PadSuperColumn.=" << &padSuperColumnVector; | |
1350 | // << "gx.=" << &gxVector | |
1351 | // << "gy.=" << &gyVector | |
1352 | // << "gz.=" << &gzVector; | |
1353 | ||
1354 | // | |
1355 | // pad calibrations | |
1356 | // | |
1357 | TObjArray arrTrash; | |
1358 | arrTrash.SetOwner(); | |
1359 | Int_t ncalib=arrCalPads.GetEntriesFast(); | |
1360 | for (Int_t iCalib=0; iCalib<ncalib; ++iCalib){ | |
1361 | AliTRDCalPad *pad=(AliTRDCalPad*)arrCalPads.UncheckedAt(iCalib); | |
1362 | AliTRDCalROC *calROC=pad->GetCalROC(chamberNo); | |
1363 | ||
1364 | TVectorD &smMean=*((TVectorD*)arrSMmean.UncheckedAt(iCalib)); | |
1365 | TVectorD &smRMS=*((TVectorD*)arrSMrms.UncheckedAt(iCalib)); | |
1366 | ||
1367 | TString calibName=pad->GetName(); | |
1368 | ||
1369 | TVectorD *valueVector=new TVectorD(nchannels); | |
1370 | arrTrash.Add(valueVector); | |
1371 | ||
1372 | Double_t rocMean=0; | |
1373 | Double_t rocRMS=0; | |
1374 | Double_t rocMedian=0; | |
1375 | ||
1376 | if (calROC){ | |
1377 | Int_t index2 = 0; | |
1378 | for(Short_t iRow=0; iRow<nrows; iRow++) { | |
1379 | for(Short_t iCol=0; iCol<ncols; iCol++) { | |
1380 | valueVector->GetMatrixArray()[index2] = calROC->GetValue(iCol,iRow); | |
1381 | index2++; | |
1382 | } | |
1383 | } | |
1384 | rocMean = calROC->GetMean(); | |
1385 | rocRMS = calROC->GetRMS(); | |
1386 | rocMedian = calROC->GetMedian(); | |
1387 | //check for NaN | |
1388 | if ( !(rocMean<1e30) ) rocMean=0; | |
1389 | if ( !(rocRMS<1e30) ) rocRMS=0; | |
1390 | ||
1391 | // printf("mean: %f\n",rocMean); | |
1392 | // printf("rms: %f\n",rocRMS); | |
1393 | // printf("median: %f\n",rocMedian); | |
1394 | } | |
1395 | ||
1396 | (*treeStreamer)<< "TRDcalibDetails" | |
1397 | // statistical information | |
1398 | << (Char_t*)((calibName+"_Mean_SuperModule=").Data()) << smMean[iSM] | |
1399 | << (Char_t*)((calibName+"_RMS_SuperModule=").Data()) << smRMS[iSM] | |
1400 | << (Char_t*)((calibName+"_Mean_Chamber=").Data()) << rocMean | |
1401 | << (Char_t*)((calibName+"_RMS_Chamber=").Data()) << rocRMS | |
1402 | << (Char_t*)((calibName+"_Median_Chamber=").Data()) << rocMedian | |
1403 | //pad by pad information | |
1404 | << (Char_t*)((calibName+".=").Data()) << valueVector; | |
1405 | ||
1406 | } // end loop over calib objects | |
1407 | ||
1408 | (*treeStreamer)<< "TRDcalibDetails" | |
1409 | << "\n"; | |
1410 | arrTrash.Delete(); | |
1411 | } // end loop over stacks | |
1412 | } // end loop over supermodules | |
1413 | } // end loop over layers | |
1414 | delete treeStreamer; | |
1415 | } | |
1416 | ||
1417 | //_____________________________________________________________________________ | |
1418 | void AliTRDCalibViewer::ProcessTRDCalibArray(AliTRDCalDet* chamberCalib, AliTRDCalPad *padCalib, | |
1419 | TString parName, | |
1420 | Double_t &runValue, Double_t &runRMS, | |
1421 | TVectorD &chamberValues, TVectorD &chamberValuesRMS, | |
1422 | TVectorD &superModuleValues, TVectorD &superModuleValuesRMS) { | |
1423 | // Process the calibrations for a given run. | |
1424 | // Calculates the run and chamber wise averages | |
1425 | // | |
1426 | if(!chamberCalib) return; | |
1427 | if(!padCalib) return; | |
1428 | Int_t kSuperModuleStatus[18] = {1, 1, 0, 0, 0, 0, // super module status (1- installed, 0- not installed) | |
1429 | 0, 1, 1, 1, 1, 0, | |
1430 | 0, 0, 0, 0, 0, 1}; | |
1431 | ||
1432 | // initialize the histograms used for extracting the mean and RMS | |
1433 | TH1F *runWiseHisto = new TH1F("runHisto", "runHisto", 200, -10.0, 10.0); | |
1434 | TH1F *superModuleWiseHisto = new TH1F("smHisto", "smHisto", 200, -10.0, 10.0); | |
1435 | TH1F *chamberWiseHisto = new TH1F("chamberHisto", "chamberHisto", 200, -10.0, 10.0); | |
1436 | ||
1437 | // check if the calibration parameter is multiplicative or additive | |
1438 | Bool_t multiplicative = kTRUE; | |
1439 | if(!parName.CompareTo("T0")) multiplicative = kFALSE; | |
1440 | ||
1441 | // first iteration (calculate all averages and RMS without discrimination on the SM average) | |
1442 | runWiseHisto->Reset(); | |
1443 | for(Int_t iSM = 0; iSM<AliTRDcalibDB::kNsector; iSM++) { // loop over supermodules | |
1444 | // reset the super module histogram | |
1445 | superModuleWiseHisto->Reset(); | |
1446 | // check if SM is installed | |
1447 | if(!kSuperModuleStatus[iSM]) continue; | |
1448 | for(Int_t iChamber=iSM*AliTRDcalibDB::kNstack*AliTRDcalibDB::kNlayer; | |
1449 | iChamber < (iSM+1)*AliTRDcalibDB::kNstack*AliTRDcalibDB::kNlayer; | |
1450 | iChamber++) { // loop over chambers in this supermodule | |
1451 | // get the chamber value | |
1452 | Float_t chamberValue = chamberCalib->GetValue(iChamber); | |
1453 | // get the ROC object | |
1454 | AliTRDCalROC *chamberROC = padCalib->GetCalROC(iChamber); | |
1455 | if(!chamberROC) | |
1456 | continue; | |
1457 | chamberWiseHisto->Reset(); | |
1458 | for(Int_t iChannel = 0; iChannel < chamberROC->GetNchannels(); iChannel++){ // loop over channels | |
1459 | // calculate the calibration parameter for this pad | |
1460 | Float_t padValue; | |
1461 | if(multiplicative) | |
1462 | padValue = chamberValue * chamberROC->GetValue(iChannel); | |
1463 | else | |
1464 | padValue = chamberValue + chamberROC->GetValue(iChannel); | |
1465 | // fill the run, SM and chamber wise histograms | |
1466 | chamberWiseHisto->Fill(padValue); | |
1467 | // if the parameter is Noise then check if the pad value is not a default one | |
1468 | // Default value is now 1.2!!!! Check with Raphaelle for more informations | |
1469 | if(parName.Contains("Noise") && | |
1470 | TMath::Abs(padValue-1.2)<0.00001) continue; | |
1471 | superModuleWiseHisto->Fill(padValue); | |
1472 | runWiseHisto->Fill(padValue); | |
1473 | } // end loop over channels | |
1474 | // get the chamber wise mean and RMS | |
1475 | chamberValues[iChamber] = chamberWiseHisto->GetMean(); | |
1476 | chamberValuesRMS[iChamber] = chamberWiseHisto->GetRMS(); | |
1477 | } // end loop over chambers | |
1478 | // SM wise mean and RMS | |
1479 | superModuleValues[iSM] = superModuleWiseHisto->GetMean(); | |
1480 | superModuleValuesRMS[iSM] = superModuleWiseHisto->GetRMS(); | |
1481 | } // end loop over supermodules | |
1482 | // run wise mean and RMS | |
1483 | runValue = runWiseHisto->GetMean(); | |
1484 | runRMS = runWiseHisto->GetRMS(); | |
1485 | ||
1486 | // Noise and Gain are finished processing | |
1487 | if(parName.Contains("Noise") || parName.Contains("Gain")) | |
1488 | return; | |
1489 | // second iteration (calculate SM and run wise averages and RMS for Vdrift and T0) | |
1490 | // The pads with calib parameter equal to the SM average are discarded (default value) | |
1491 | runWiseHisto->Reset(); | |
1492 | for(Int_t iSM = 0; iSM<AliTRDcalibDB::kNsector; iSM++) { // loop over supermodules | |
1493 | superModuleWiseHisto->Reset(); | |
1494 | // eliminate the uninstalled super modules | |
1495 | if(!kSuperModuleStatus[iSM]) continue; | |
1496 | for(Int_t iChamber=iSM*AliTRDcalibDB::kNstack*AliTRDcalibDB::kNlayer; | |
1497 | iChamber < (iSM+1)*AliTRDcalibDB::kNstack*AliTRDcalibDB::kNlayer; | |
1498 | iChamber++) { // loop over chambers | |
1499 | // the chamber value | |
1500 | Float_t chamberValue = chamberCalib->GetValue(iChamber); | |
1501 | AliTRDCalROC *chamberROC = padCalib->GetCalROC(iChamber); | |
1502 | if(!chamberROC) | |
1503 | continue; | |
1504 | ||
1505 | for(Int_t iChannel = 0; iChannel < chamberROC->GetNchannels(); iChannel++){ // loop over channels in a chamber | |
1506 | // get the pad value | |
1507 | Float_t padValue; | |
1508 | if(multiplicative) | |
1509 | padValue = chamberValue * chamberROC->GetValue(iChannel); | |
1510 | else | |
1511 | padValue = chamberValue + chamberROC->GetValue(iChannel); | |
1512 | // eliminate from the average and RMS calculation all pads which | |
1513 | // have the calib parameter equal with the SM average | |
1514 | if((parName.Contains("Vdrift") || parName.Contains("T0")) && | |
1515 | TMath::Abs(padValue-superModuleValues[iSM])<0.00001) continue; | |
1516 | superModuleWiseHisto->Fill(padValue); | |
1517 | runWiseHisto->Fill(padValue); | |
1518 | } // end loop over channels | |
1519 | } // end loop over chambers | |
1520 | ||
1521 | superModuleValues[iSM] = superModuleWiseHisto->GetMean(); | |
1522 | superModuleValuesRMS[iSM] = superModuleWiseHisto->GetRMS(); | |
1523 | } // end loop over super modules | |
1524 | runValue = runWiseHisto->GetMean(); | |
1525 | runRMS = runWiseHisto->GetRMS(); | |
1526 | ||
1527 | delete chamberWiseHisto; | |
1528 | delete superModuleWiseHisto; | |
1529 | delete runWiseHisto; | |
1530 | ||
1531 | return; | |
1532 | } | |
1533 | ||
1534 | ||
1535 | //_____________________________________________________________________________ | |
1536 | void AliTRDCalibViewer::ProcessTRDCalibArray(AliTRDCalPad *padCalib, | |
1537 | TVectorD &superModuleValues, TVectorD &superModuleValuesRMS) | |
1538 | { | |
1539 | // Process the calibrations for a given run. | |
1540 | // Calculates the run and chamber wise averages | |
1541 | ||
1542 | if(!padCalib) return; | |
1543 | Int_t kSuperModuleStatus[18] = {1, 1, 0, 0, 0, 0, // super module status (1- installed, 0- not installed) | |
1544 | 0, 1, 1, 1, 1, 0, | |
1545 | 0, 0, 0, 0, 0, 1}; | |
1546 | ||
1547 | for(Int_t iSM = 0; iSM<AliTRDcalibDB::kNsector; iSM++) { // loop over supermodules | |
1548 | Double_t mean=0; | |
1549 | Double_t rms=0; | |
1550 | Double_t count=0; | |
1551 | if(!kSuperModuleStatus[iSM]) continue; | |
1552 | ||
1553 | // loop over chambers in this supermodule | |
1554 | const Int_t nchambers=AliTRDcalibDB::kNstack*AliTRDcalibDB::kNlayer; | |
1555 | for(Int_t iChamber=iSM*nchambers; iChamber < (iSM+1)*nchambers; iChamber++) { | |
1556 | AliTRDCalROC *chamberROC = padCalib->GetCalROC(iChamber); | |
1557 | if(!chamberROC) | |
1558 | continue; | |
1559 | ||
1560 | // loop over channels | |
1561 | for(Int_t iChannel = 0; iChannel < chamberROC->GetNchannels(); iChannel++){ | |
1562 | mean+=chamberROC->GetValue(iChannel); | |
1563 | rms+=chamberROC->GetValue(iChannel)*chamberROC->GetValue(iChannel); | |
1564 | ++count; | |
1565 | } // end loop over channels | |
1566 | } // end loop over chambers | |
1567 | ||
1568 | //calculate mean and rms | |
1569 | if (count>0){ | |
1570 | mean/=count; | |
1571 | rms/=count; | |
1572 | rms=TMath::Sqrt(TMath::Abs(mean*mean-rms)); | |
1573 | } | |
1574 | // SM wise mean and RMS | |
1575 | superModuleValues[iSM] = mean; | |
1576 | superModuleValuesRMS[iSM] = rms; | |
1577 | } // end loop over supermodules | |
1578 | } |