]>
Commit | Line | Data |
---|---|---|
e22bf775 | 1 | #if !defined(__CINT__) || defined(__MAKECINT__) |
2 | #include <TTimeStamp.h> | |
3 | #include <TMap.h> | |
4 | #include <TMath.h> | |
5 | #include <TFile.h> | |
6 | #include <TObjArray.h> | |
7 | #include <TObjString.h> | |
8 | #include <TRandom.h> | |
9 | #include <TSystem.h> | |
10 | #include <AliDCSValue.h> | |
11 | #endif | |
12 | ||
e22bf775 | 13 | ////////////////////////////////////////////////////////////////////////////////////// |
14 | // Generator of testing data for AliITSDCSPreprocessorSDD and AliITSAnalyzerrSDD // | |
15 | // Origin: F.Prino, Torino, prino@to.infn.it // | |
16 | // V.Pospisil, CTU Prague, gdermog@seznam.cz // | |
17 | ////////////////////////////////////////////////////////////////////////////////////// | |
18 | ||
e22bf775 | 19 | TMap* CreateRealisticMap( TTimeStamp startTime, TTimeStamp stopTime ); |
20 | TMap* CreateRandomMap( Int_t maxRecords = 1000, Int_t randomTimeStamps = 0 ); | |
21 | void GenerateOutputFiles( TMap *map, char *dir ); | |
22 | ||
dc5eacf8 | 23 | Int_t sizeOfMapContent = 0; |
e22bf775 | 24 | |
25 | void CreateSDDDCSMap( void ) | |
26 | { | |
27 | ||
28 | TTimeStamp startT( 2008, 2, 7, 15, 0, 0 ); | |
29 | TTimeStamp stopT( 2008, 2, 7, 18, 0, 0 ); | |
30 | // The beginning and the end of the simulated run | |
31 | ||
32 | // delete gRandom; | |
33 | // gRandom = new TRandom2; | |
34 | gRandom->SetSeed(0); | |
35 | ||
36 | /* Macro can generate random purely random data or simulate DCS. Choose | |
37 | one of the methods - CreateRandomMap() or CreateRealisticMap() */ | |
38 | ||
39 | // TMap *outMap = CreateRandomMap( 1000 ); | |
40 | TMap *outMap = CreateRealisticMap( startT, stopT ); | |
41 | ||
42 | GenerateOutputFiles( outMap, "./maps_3h_SIM" ); | |
43 | ||
44 | TFile newfile( "DCSAliasMap_3h_SIM.root", "RECREATE" ); | |
45 | ||
46 | printf( "Writting map into the file ...\n"); | |
47 | ||
48 | outMap->Write( "DCSAliasMap", TObject::kSingleKey ); | |
49 | ||
dc5eacf8 | 50 | printf( "DCSAliasMap created, it size is %i byte ...\n", sizeOfMapContent ); |
e22bf775 | 51 | |
52 | } /*CreateMap*/ | |
53 | ||
54 | ||
55 | /***************************************************************/ | |
56 | /* DCS simulation setup - used in CreateRealisticMap() */ | |
57 | /* Choose simulation setup by changing following variables */ | |
58 | /***************************************************************/ | |
59 | ||
60 | // --- Temperature (left side) - behavior of SDD chip ----------- | |
61 | ||
62 | Float_t mvalTL = 20.0; // Mean value of temperature | |
63 | Float_t fluctTL = 0.5; // Fluctuation (gaussian sigma) | |
64 | ||
65 | // --- Temperature readout (left side) - behavior of DCS -------- | |
66 | ||
dc5eacf8 | 67 | Int_t freqROTL = 300; // Frequency of fixed readout |
e22bf775 | 68 | Float_t fluctROTL = 5.0; |
69 | // Allowed fluctuation (%) | |
70 | ||
71 | // Temperature readout status (left side) - behavior of SDD chip | |
72 | ||
dc5eacf8 | 73 | Int_t freqROStTL = 300;// Frequency of fixed readout |
e22bf775 | 74 | Float_t failureTL = 0.01; |
75 | // Probability of thermometer | |
76 | // failure (in one hour) | |
77 | ||
78 | // --- Temperature (right side) - behavior of SDD chip ---------- | |
79 | ||
80 | Float_t mvalTR = 20.0; // Mean value of temperature | |
81 | Float_t fluctTR = 0.5;// Fluctuation (gaussian sigma) | |
82 | ||
83 | // --- Temperature readout (right side) - behavior of DCS ------- | |
84 | ||
dc5eacf8 | 85 | Int_t freqROTR = 300; // Frequency of fixed readout |
e22bf775 | 86 | Float_t fluctROTR = 5.0; |
87 | // Allowed fluctuation (%) | |
88 | ||
89 | // Temperature readout status (right side) - behavior of SDD | |
90 | ||
dc5eacf8 | 91 | Int_t freqROStTR = 300;// Frequency of fixed readout |
e22bf775 | 92 | Float_t failureTR = 0.01; |
93 | // Probability of thermometer | |
94 | // failure (in one hour) | |
95 | ||
96 | // --- High voltage - behavior of SDD voltage source ----------- | |
97 | ||
98 | Float_t mvalHV = 1791.0; | |
99 | // Mean value of HV | |
dc5eacf8 | 100 | Float_t fluctHV = 0.03;// Fluctuation (gaussian sigma) |
e22bf775 | 101 | |
102 | // --- High voltage readout - behavior of DCS ------------------- | |
103 | ||
dc5eacf8 | 104 | Int_t freqROHV = 300; // Frequency of fixed readout |
e22bf775 | 105 | Float_t fluctROHV = 0.01; |
106 | // Allowed fluctuation (%) | |
107 | ||
108 | // --- High voltage readout status - behavior of SDD voltage ---- | |
109 | ||
dc5eacf8 | 110 | Int_t freqROOK = 300; // Frequency of fixed readout |
e22bf775 | 111 | Float_t failureHV = 0.005; |
112 | // Probability of HV source | |
113 | // failure (in one hour) | |
114 | ||
115 | // --- Medium voltage - behavior of SDD voltage source -------- | |
116 | ||
117 | Float_t mvalMV = 45.0; // Mean value of MV | |
dc5eacf8 | 118 | Float_t fluctMV = 0.005; |
119 | // Fluctuation (gaussian sigma) | |
e22bf775 | 120 | |
121 | // --- Medium voltage readout - behavior of DCS ----------------- | |
122 | ||
dc5eacf8 | 123 | Int_t freqROMV = 300; // Frequency of fixed readout |
e22bf775 | 124 | Float_t fluctROMV = 0.1; |
125 | // Allowed fluctuation (%) | |
126 | ||
127 | // --- Medium voltage readout status - behavior of SDD voltage -- | |
128 | ||
129 | Float_t failureMV = 0.005; | |
130 | // Probability of MV source | |
131 | // failure (in one hour) | |
132 | ||
133 | /***************************************************************/ | |
134 | /* ITS geometry setup */ | |
135 | /***************************************************************/ | |
136 | ||
137 | Int_t kNladders3=14; | |
138 | Int_t kNladders4=22; | |
139 | Int_t kNmodLad3=6; | |
140 | Int_t kNmodLad4=8; | |
141 | ||
142 | /***************************************************************/ | |
143 | ||
144 | //---------------------------------------------------------------------------------------- | |
145 | ||
146 | TMap* CreateRealisticMap( TTimeStamp startTime, TTimeStamp stopTime ) | |
147 | { | |
148 | // Creates a DCS structure | |
149 | // The structure is the following: | |
150 | // TMap (key --> value) | |
151 | // <DCSAlias> --> <valueList> | |
152 | // <DCSAlias> is a string | |
153 | // <valueList> is a TObjArray of AliDCSValue | |
154 | // An AliDCSValue consists of timestamp and a value in form of a AliSimpleValue | |
155 | ||
156 | TMap* aliasMap = new TMap; | |
157 | aliasMap->SetOwner(1); | |
158 | // Empty map is created | |
159 | ||
dc5eacf8 | 160 | sizeOfMapContent += sizeof( TMap ); |
161 | ||
e22bf775 | 162 | TString aliasName; |
163 | Char_t dpName[50]; | |
164 | Int_t created = 0; | |
165 | Int_t created1 = 0; // DCS records counter | |
166 | ||
167 | Double_t failureTLpersec; | |
168 | Double_t failureTRpersec; | |
169 | Double_t failureHVpersec; | |
170 | Double_t failureMVpersec; | |
171 | // Probabilities of failure per one second | |
172 | Double_t lambda; | |
173 | lambda = ( TMath::Log( 1.0 - failureTL ) ) / -3600.0; | |
174 | failureTLpersec = 1.0 - TMath::Exp(-lambda ); | |
175 | lambda = ( TMath::Log( 1.0 - failureTR ) ) / -3600.0; | |
176 | failureTRpersec = 1.0 - TMath::Exp(-lambda ); | |
177 | lambda = ( TMath::Log( 1.0 - failureHV ) ) / -3600.0; | |
178 | failureHVpersec = 1.0 - TMath::Exp(-lambda ); | |
179 | lambda = ( TMath::Log( 1.0 - failureMV ) ) / -3600.0; | |
180 | failureMVpersec = 1.0 - TMath::Exp(-lambda ); | |
181 | // Probabilities of failure per one second are counted | |
182 | ||
183 | fluctROTL /= 100.0; | |
184 | fluctROTR /= 100.0; | |
185 | fluctROHV /= 100.0; | |
186 | fluctROMV /= 100.0; // Percents to fractions | |
187 | ||
188 | Double_t failureOK = ( failureHV + failureMV ) / 2.0; | |
189 | // This value is used only for noise in timing | |
190 | ||
191 | for( Int_t iLay = 3; iLay < 5; iLay++ ) | |
192 | { | |
193 | ||
194 | Int_t maxLad = ( iLay == 3) ? kNladders3 : kNladders4; | |
195 | Int_t maxMod = ( iLay == 3) ? kNmodLad3 : kNmodLad4; | |
196 | ||
197 | for(Int_t iLad=0; iLad<maxLad; iLad++) | |
198 | { | |
199 | for(Int_t iMod=0; iMod<maxMod; iMod++) | |
200 | { | |
201 | ||
202 | fprintf( stderr, "Simulating data taking for layer %i, ladder %i, module %i ... \n", iLay, iLad, iMod ); | |
203 | ||
204 | TObjArray* valueSetOK = new TObjArray; | |
205 | TObjArray* valueSetHV = new TObjArray; | |
206 | TObjArray* valueSetMV = new TObjArray; | |
207 | TObjArray* valueSetTL = new TObjArray; | |
208 | TObjArray* valueSetTR = new TObjArray; | |
209 | TObjArray* valueSetStTL = new TObjArray; | |
210 | TObjArray* valueSetStTR = new TObjArray; | |
211 | ||
dc5eacf8 | 212 | sizeOfMapContent += 7 * sizeof( TObjArray ); |
213 | ||
e22bf775 | 214 | valueSetOK->SetOwner(1); |
215 | valueSetHV->SetOwner(1); | |
216 | valueSetMV->SetOwner(1); | |
217 | valueSetTL->SetOwner(1); | |
218 | valueSetTR->SetOwner(1); | |
219 | valueSetStTL->SetOwner(1); | |
220 | valueSetStTR->SetOwner(1); | |
221 | ||
222 | Float_t actualTL, actualTR; | |
223 | Float_t actualHV, actualMV; | |
224 | Int_t actualStTL = 1; | |
225 | Int_t actualStTR = 1; | |
226 | Int_t actualStHV = 1; | |
227 | Int_t actualStMV = 1; | |
228 | // Readout devices are alive/dead | |
229 | ||
230 | Float_t lastTL = mvalTL; | |
231 | Float_t lastTR = mvalTR; | |
232 | Float_t lastHV = mvalHV; | |
233 | Float_t lastMV = mvalMV; | |
234 | // Last written values - udes for threshold readout | |
235 | ||
236 | Int_t counterTL = 0; | |
237 | Int_t counterTR = 0; | |
238 | Int_t counterHV = 0; | |
239 | Int_t counterMV = 0; | |
240 | Int_t counterStTL = 0; | |
241 | Int_t counterStTR = 0; | |
242 | Int_t counterOK = 0; | |
243 | // Periodic readout counters | |
244 | ||
dc5eacf8 | 245 | Int_t endingTimeStamp = /*1197477000;*/ stopTime.GetSec(); |
e22bf775 | 246 | |
dc5eacf8 | 247 | for( Int_t timeLoop = /*1197470000 */ startTime.GetSec(); timeLoop < endingTimeStamp; timeLoop ++ ) |
e22bf775 | 248 | { // Loop goes through period of run second per second and determines |
249 | // all values according to rules of DCS | |
250 | ||
251 | actualTL = gRandom->Gaus( mvalTL, fluctTL ); | |
252 | actualTR = gRandom->Gaus( mvalTR, fluctTR ); | |
253 | actualHV = gRandom->Gaus( mvalHV, fluctHV ); | |
254 | actualMV = gRandom->Gaus( mvalMV, fluctMV ); | |
255 | // Generates random values of temperatures and voltages | |
256 | // in given ranges | |
257 | ||
258 | if( gRandom->Rndm() < failureTLpersec ) | |
259 | if( actualStTL ) actualStTL = 0; else if( gRandom->Rndm() < 0.1 ) actualStTL = 1; | |
260 | if( gRandom->Rndm() < failureTRpersec ) | |
261 | if( actualStTR ) actualStTR = 0; else if( gRandom->Rndm() < 0.1 ) actualStTR = 1; | |
262 | if( gRandom->Rndm() < failureHVpersec ) | |
263 | if( actualStHV ) actualStHV = 0; else if( gRandom->Rndm() < 0.1 ) actualStHV = 1; | |
264 | if( gRandom->Rndm() < failureMVpersec ) | |
265 | if( actualStMV ) actualStMV = 0; else if( gRandom->Rndm() < 0.1 ) actualStMV = 1; | |
266 | // Decides if any thermometer or voltage source becomes | |
267 | // dead (or alive again, but this have much 10x les probability ) | |
268 | ||
269 | if( gRandom->Rndm() < failureTL ) counterTL++; | |
270 | if( gRandom->Rndm() < failureTL ) counterTL--; | |
271 | if( gRandom->Rndm() < failureTR ) counterTR++; | |
272 | if( gRandom->Rndm() < failureTR ) counterTR--; | |
273 | if( gRandom->Rndm() < failureHV ) counterHV++; | |
274 | if( gRandom->Rndm() < failureHV ) counterHV--; | |
275 | if( gRandom->Rndm() < failureMV ) counterMV++; | |
276 | if( gRandom->Rndm() < failureMV ) counterMV--; | |
277 | if( gRandom->Rndm() < failureTL ) counterStTL++; | |
278 | if( gRandom->Rndm() < failureTL ) counterStTL--; | |
279 | if( gRandom->Rndm() < failureTR ) counterStTR++; | |
280 | if( gRandom->Rndm() < failureTR ) counterStTR--; | |
281 | if( gRandom->Rndm() < failureOK ) counterOK++; | |
282 | if( gRandom->Rndm() < failureOK ) counterOK--; | |
283 | // Simulating noise in the clock frequency | |
284 | ||
285 | if( counterTL >= freqROTL ) | |
286 | { valueSetTL->Add( new AliDCSValue( actualTL, timeLoop ) ); lastTL = actualTL; counterTL = 0; created++; } | |
287 | if( counterTR >= freqROTR ) | |
288 | { valueSetTR->Add( new AliDCSValue( actualTR, timeLoop ) ); lastTR = actualTR; counterTR = 0; created++; } | |
289 | if( counterHV >= freqROHV ) | |
290 | { valueSetHV->Add( new AliDCSValue( actualHV, timeLoop ) ); lastHV = actualHV; counterHV = 0; created++; } | |
291 | if( counterMV >= freqROMV ) | |
292 | { valueSetMV->Add( new AliDCSValue( actualMV, timeLoop ) ); lastMV = actualMV; counterMV = 0; created++; } | |
293 | if( counterStTL >= freqROStTL ) | |
294 | { valueSetStTL->Add( new AliDCSValue( actualStTL, timeLoop ) ); counterStTL = 0; created++; } | |
295 | if( counterStTR >= freqROStTR ) | |
296 | { valueSetStTR->Add( new AliDCSValue( actualStTR, timeLoop ) ); counterStTR = 0; created++; } | |
297 | if( counterOK >= freqROOK ) | |
298 | { valueSetOK->Add( new AliDCSValue( (Bool_t)(actualStHV & actualStMV), timeLoop ) ); counterOK = 0; created++; } | |
299 | // Periodic readout | |
300 | ||
301 | if( TMath::Abs( (lastTL - actualTL) / lastTL ) > fluctROTL ) | |
302 | { valueSetTL->Add( new AliDCSValue( actualTL, timeLoop ) ); lastTL = actualTL; counterTL = 0; created1++; } | |
303 | if( TMath::Abs( (lastTR - actualTR) / lastTR ) > fluctROTR ) | |
304 | { valueSetTR->Add( new AliDCSValue( actualTR, timeLoop ) ); lastTR = actualTR; counterTR = 0; created1++; } | |
305 | if( TMath::Abs( (lastHV - actualHV) / lastHV ) > fluctROHV ) | |
306 | { valueSetHV->Add( new AliDCSValue( actualHV, timeLoop ) ); lastHV = actualHV; counterHV = 0; created1++; } | |
307 | if( TMath::Abs( (lastMV - actualMV) / lastMV ) > fluctROMV ) | |
308 | { valueSetMV->Add( new AliDCSValue( actualMV, timeLoop ) ); lastMV = actualMV; counterMV = 0; created1++; } | |
309 | // Treshold readout | |
310 | ||
311 | counterTL++; | |
312 | counterTR++; | |
313 | counterHV++; | |
314 | counterMV++; | |
315 | counterStTL++; | |
316 | counterStTR++; | |
317 | counterOK++; | |
318 | ||
319 | } /*for( timeLoop )*/ | |
320 | ||
321 | sprintf( dpName, "SDD_LAYER%i_LADDER%02d_MODULE%d_OK", iLay, iLad, iMod ); | |
322 | aliasName = dpName; | |
323 | aliasMap->Add( new TObjString(aliasName), valueSetOK ); | |
324 | ||
325 | sprintf( dpName, "SDD_LAYER%i_LADDER%02d_MODULE%d_HV", iLay, iLad, iMod ); | |
326 | aliasName = dpName; | |
327 | aliasMap->Add( new TObjString(aliasName), valueSetHV ); | |
328 | ||
329 | sprintf( dpName, "SDD_LAYER%i_LADDER%02d_MODULE%d_MV", iLay, iLad, iMod ); | |
330 | aliasName = dpName; | |
331 | aliasMap->Add( new TObjString(aliasName), valueSetMV ); | |
332 | ||
333 | sprintf( dpName, "SDD_LAYER%i_LADDER%02d_MODULE%d_TEMP_L", iLay, iLad, iMod ); | |
334 | aliasName = dpName; | |
335 | aliasMap->Add( new TObjString(aliasName), valueSetTL ); | |
336 | ||
337 | sprintf( dpName, "SDD_LAYER%i_LADDER%02d_MODULE%d_TEMP_R", iLay, iLad, iMod ); | |
338 | aliasName = dpName; | |
339 | aliasMap->Add( new TObjString(aliasName), valueSetTR ); | |
340 | ||
341 | sprintf( dpName, "SDD_LAYER%i_LADDER%02d_MODULE%d_TEMP_L_STATE", iLay, iLad, iMod ); | |
342 | aliasName = dpName; | |
343 | aliasMap->Add( new TObjString(aliasName), valueSetStTL ); | |
344 | ||
345 | sprintf( dpName, "SDD_LAYER%i_LADDER%02d_MODULE%d_TEMP_R_STATE", iLay, iLad, iMod ); | |
346 | aliasName = dpName; | |
347 | aliasMap->Add( new TObjString(aliasName), valueSetStTR ); | |
348 | ||
349 | } /*for( iMod ) */ | |
350 | } /*for( iLad )*/ | |
351 | } /*for( iLay )*/ | |
352 | ||
353 | fprintf( stderr, "\nCreated %i objects of type AliDCSValue (%i periodic + %i treshold)... \n", | |
354 | created + created1, created, created1 ); | |
355 | ||
dc5eacf8 | 356 | sizeOfMapContent += (created + created1 ) * ( sizeof( AliDCSValue ) + sizeof( AliDCSValue * ) ); |
357 | ||
e22bf775 | 358 | return aliasMap; |
359 | ||
360 | } /*CreateRealisticMap*/ | |
361 | ||
362 | //---------------------------------------------------------------------------------------- | |
363 | ||
364 | ||
365 | TMap* CreateRandomMap( Int_t maxRecords , Int_t randomTimeStamps ) | |
366 | { | |
367 | // Creates a DCS structure | |
368 | // The structure is the following: | |
369 | // TMap (key --> value) | |
370 | // <DCSAlias> --> <valueList> | |
371 | // <DCSAlias> is a string | |
372 | // <valueList> is a TObjArray of AliDCSValue | |
373 | // An AliDCSValue consists of timestamp and a value in form of a AliSimpleValue | |
374 | ||
375 | ||
376 | TMap* aliasMap = new TMap; | |
377 | aliasMap->SetOwner(1); | |
378 | ||
dc5eacf8 | 379 | sizeOfMapContent += sizeof( TMap ); |
e22bf775 | 380 | |
381 | TString aliasName; | |
382 | Char_t dpName[50]; | |
383 | Int_t created = 0; | |
384 | ||
385 | for( Int_t iLay = 3; iLay < 5; iLay++ ) | |
386 | { | |
387 | ||
388 | Int_t maxLad = ( iLay == 3) ? kNladders3 : kNladders4; | |
389 | Int_t maxMod = ( iLay == 3) ? kNmodLad3 : kNmodLad4; | |
390 | ||
391 | for(Int_t iLad = 0; iLad < maxLad; iLad++) | |
392 | { | |
393 | for(Int_t iMod =0 ; iMod < maxMod;iMod++) | |
394 | { | |
395 | ||
396 | fprintf( stderr, "Generating data for layer %i, ladder %i, module %i ... \n", iLay, iLad, iMod ); | |
397 | ||
398 | TObjArray* valueSetOK = new TObjArray; | |
399 | TObjArray* valueSetH = new TObjArray; | |
400 | TObjArray* valueSetM = new TObjArray; | |
401 | TObjArray* valueSetTL = new TObjArray; | |
402 | TObjArray* valueSetTR = new TObjArray; | |
403 | TObjArray* valueSetStTL = new TObjArray; | |
404 | TObjArray* valueSetStTR = new TObjArray; | |
405 | ||
dc5eacf8 | 406 | sizeOfMapContent += 7 * sizeof( TObjArray ); |
407 | ||
e22bf775 | 408 | valueSetOK->SetOwner(1); |
409 | valueSetH->SetOwner(1); | |
410 | valueSetM->SetOwner(1); | |
411 | valueSetTL->SetOwner(1); | |
412 | valueSetTR->SetOwner(1); | |
413 | valueSetStTL->SetOwner(1); | |
414 | valueSetStTR->SetOwner(1); | |
415 | ||
416 | Int_t nrOfRecords; | |
417 | AliDCSValue* dcsVal; | |
418 | Int_t timeStamp; | |
419 | ||
420 | sprintf(dpName,"SDD_LAYER%i_LADDER%02d_MODULE%d_OK", iLay,iLad,iMod); | |
421 | aliasName=dpName; | |
dc5eacf8 | 422 | nrOfRecords = (Int_t)(maxRecords * ( gRandom->Rndm() ) ); |
e22bf775 | 423 | timeStamp = 1000000000; |
dc5eacf8 | 424 | for( Int_t recLoop = 0; recLoop < nrOfRecords; recLoop ++ ) |
e22bf775 | 425 | { |
426 | if( randomTimeStamps ) | |
427 | timeStamp = (Int_t)(1200000000*(gRandom->Rndm())); | |
428 | else | |
429 | timeStamp += (Int_t)(50*(gRandom->Rndm()) ); | |
dc5eacf8 | 430 | if( 1000*(gRandom->Rndm()) > 50 ) |
431 | dcsVal = new AliDCSValue((Bool_t)1, timeStamp); | |
432 | else | |
433 | dcsVal = new AliDCSValue((Bool_t)0, timeStamp); | |
434 | valueSetOK->Add(dcsVal); | |
e22bf775 | 435 | } /*for( recLoop )*/ |
436 | aliasMap->Add(new TObjString(aliasName), valueSetOK); | |
437 | created += nrOfRecords; | |
438 | ||
439 | sprintf(dpName,"SDD_LAYER%i_LADDER%02d_MODULE%d_HV", iLay, iLad,iMod); | |
440 | aliasName=dpName; | |
441 | nrOfRecords = (Int_t)(maxRecords * ( gRandom->Rndm() )); | |
442 | timeStamp = 1000000000; | |
443 | for( Int_t recLoop = 0; recLoop < nrOfRecords; recLoop ++ ) | |
444 | { | |
445 | if( randomTimeStamps ) | |
446 | timeStamp = (Int_t)(1200000000*(gRandom->Rndm())); | |
447 | else | |
dc5eacf8 | 448 | timeStamp += (Int_t)(50*(gRandom->Rndm()) ); |
e22bf775 | 449 | dcsVal = new AliDCSValue( (Float_t)( 1600 + 200*(gRandom->Rndm()) ), timeStamp ); |
450 | valueSetH->Add(dcsVal); | |
e22bf775 | 451 | } /*for( recLoop )*/ |
452 | aliasMap->Add(new TObjString(aliasName), valueSetH); | |
453 | created += nrOfRecords; | |
454 | ||
455 | sprintf(dpName,"SDD_LAYER%i_LADDER%02d_MODULE%d_MV", iLay, iLad,iMod); | |
456 | aliasName=dpName; | |
dc5eacf8 | 457 | nrOfRecords = (Int_t)(maxRecords * ( gRandom->Rndm() )); |
e22bf775 | 458 | timeStamp = 1000000000; |
459 | for( Int_t recLoop = 0; recLoop < nrOfRecords; recLoop ++ ) | |
460 | { | |
461 | if( randomTimeStamps ) | |
462 | timeStamp = (Int_t)(1200000000*(gRandom->Rndm())); | |
463 | else | |
dc5eacf8 | 464 | timeStamp += (Int_t)(50*(gRandom->Rndm()) ); |
e22bf775 | 465 | dcsVal = new AliDCSValue( (Float_t)( 30 + 20*(gRandom->Rndm()) ), timeStamp ); |
466 | valueSetM->Add(dcsVal); | |
467 | } /*for( recLoop )*/ | |
468 | aliasMap->Add(new TObjString(aliasName), valueSetM); | |
469 | created += nrOfRecords; | |
470 | ||
471 | sprintf(dpName,"SDD_LAYER%i_LADDER%02d_MODULE%d_TEMP_L", iLay, iLad,iMod); | |
472 | aliasName=dpName; | |
dc5eacf8 | 473 | nrOfRecords = (Int_t)(maxRecords * ( gRandom->Rndm() )); |
e22bf775 | 474 | timeStamp = 1000000000; |
475 | for( Int_t recLoop = 0; recLoop < nrOfRecords; recLoop ++ ) | |
476 | { | |
477 | if( randomTimeStamps ) | |
478 | timeStamp = (Int_t)(1200000000*(gRandom->Rndm())); | |
dc5eacf8 | 479 | else |
480 | timeStamp += (Int_t)(50*(gRandom->Rndm()) ); | |
e22bf775 | 481 | dcsVal = new AliDCSValue( (Float_t)( 50 + 50*(gRandom->Rndm()) ), timeStamp ); |
482 | valueSetTL->Add(dcsVal); | |
483 | } /*for( recLoop )*/ | |
484 | aliasMap->Add(new TObjString(aliasName), valueSetTL); | |
485 | created += nrOfRecords; | |
486 | ||
487 | sprintf(dpName,"SDD_LAYER%i_LADDER%02d_MODULE%d_TEMP_R", iLay, iLad,iMod); | |
488 | aliasName=dpName; | |
dc5eacf8 | 489 | nrOfRecords = (Int_t)(maxRecords * ( gRandom->Rndm() )); |
490 | timeStamp = 1000000000; | |
e22bf775 | 491 | for( Int_t recLoop = 0; recLoop < nrOfRecords; recLoop ++ ) |
492 | { | |
493 | if( randomTimeStamps ) | |
494 | timeStamp = (Int_t)(1200000000*(gRandom->Rndm())); | |
495 | else | |
dc5eacf8 | 496 | timeStamp += (Int_t)(50*(gRandom->Rndm()) ); |
e22bf775 | 497 | dcsVal = new AliDCSValue( (Float_t)( 50 + 50*(gRandom->Rndm()) ), timeStamp ); |
498 | valueSetTR->Add(dcsVal); | |
499 | } /*for( recLoop )*/ | |
500 | aliasMap->Add(new TObjString(aliasName), valueSetTR); | |
501 | created += nrOfRecords; | |
502 | ||
503 | sprintf(dpName,"SDD_LAYER%i_LADDER%02d_MODULE%d_TEMP_L_STATE", iLay, iLad,iMod); | |
504 | aliasName=dpName; | |
dc5eacf8 | 505 | nrOfRecords = (Int_t)(maxRecords * ( gRandom->Rndm() )); |
e22bf775 | 506 | timeStamp = 1000000000; |
507 | for( Int_t recLoop = 0; recLoop < nrOfRecords; recLoop ++ ) | |
508 | { | |
509 | if( randomTimeStamps ) | |
dc5eacf8 | 510 | timeStamp = (Int_t)(1200000000*(gRandom->Rndm())); |
e22bf775 | 511 | else |
dc5eacf8 | 512 | timeStamp += (Int_t)(50*(gRandom->Rndm()) ); |
e22bf775 | 513 | if( 1000*(gRandom->Rndm()) > 50 ) |
514 | dcsVal = new AliDCSValue((Int_t)1, timeStamp); | |
515 | else | |
516 | dcsVal = new AliDCSValue((Int_t)0, timeStamp); | |
517 | valueSetStTL->Add(dcsVal); | |
518 | } /*for( recLoop )*/ | |
519 | aliasMap->Add(new TObjString(aliasName), valueSetStTL); | |
520 | created += nrOfRecords; | |
521 | ||
522 | sprintf(dpName,"SDD_LAYER%i_LADDER%02d_MODULE%d_TEMP_R_STATE", iLay, iLad,iMod); | |
523 | aliasName=dpName; | |
dc5eacf8 | 524 | nrOfRecords = (Int_t)(maxRecords * ( gRandom->Rndm() )); |
e22bf775 | 525 | timeStamp = 1000000000; |
526 | for( Int_t recLoop = 0; recLoop < nrOfRecords; recLoop ++ ) | |
527 | { | |
528 | if( randomTimeStamps ) | |
529 | timeStamp = (Int_t)(1200000000*(gRandom->Rndm())); | |
530 | else | |
dc5eacf8 | 531 | timeStamp += (Int_t)(50*(gRandom->Rndm()) ); |
e22bf775 | 532 | if( 1000*(gRandom->Rndm()) > 50 ) |
533 | dcsVal = new AliDCSValue((Int_t)1, timeStamp); | |
534 | else | |
535 | dcsVal = new AliDCSValue((Int_t)0, timeStamp); | |
536 | valueSetStTR->Add(dcsVal); | |
537 | ||
538 | } /*for( recLoop )*/ | |
539 | aliasMap->Add(new TObjString(aliasName), valueSetStTR); | |
540 | created += nrOfRecords; | |
541 | ||
542 | } /*for( iMod ) */ | |
543 | } /*for( iLad )*/ | |
544 | ||
545 | } /*for( iLay )*/ | |
546 | ||
547 | fprintf( stderr, "\nCreated %i objects of type AliDCSValue ... \n", created); | |
548 | ||
dc5eacf8 | 549 | sizeOfMapContent += created * ( sizeof( AliDCSValue ) + sizeof( AliDCSValue * ) ); |
550 | ||
e22bf775 | 551 | return aliasMap; |
552 | } | |
553 | ||
554 | // ----------------------------------------------------------------------------- | |
555 | ||
556 | void GenerateOutputFiles( TMap *map, char *dir ) | |
557 | { | |
558 | ||
559 | FILE *outputFile; | |
560 | char buffer[100],cmd[100]; | |
561 | Int_t nHVEntries, nMVEntries, nTLEntries, nTREntries; | |
562 | Int_t nOKEntries, nStTLEntries, nStTREntries; | |
dc5eacf8 | 563 | |
e22bf775 | 564 | sprintf(cmd,"ls -l %s >/dev/null 2>&1",dir); |
565 | if(gSystem->Exec(cmd)!=0){ | |
566 | printf("%s --- NOT EXISTS -- create it\n",dir); | |
567 | sprintf(cmd,"mkdir %s",dir); | |
568 | gSystem->Exec(cmd); | |
569 | } | |
570 | ||
571 | for( Int_t iLay = 3; iLay < 5; iLay++ ) | |
572 | { | |
573 | ||
574 | Int_t maxLad = ( iLay == 3) ? kNladders3 : kNladders4; | |
575 | Int_t maxMod = ( iLay == 3) ? kNmodLad3 : kNmodLad4; | |
576 | ||
577 | for(Int_t iLad = 0; iLad < maxLad; iLad++) | |
578 | { | |
579 | ||
580 | ||
581 | for(Int_t iMod = 0; iMod < maxMod; iMod++) | |
582 | { | |
583 | ||
584 | sprintf( buffer, "%s/DCSMapContent_SDD_LAYER%i_LADDER%02d_MODULE%d.txt", dir, iLay, iLad, iMod ); | |
585 | ||
586 | fprintf( stderr, "Creating file %s ... ", buffer ); | |
587 | outputFile = fopen( buffer, "w" ); | |
588 | if( outputFile == NULL ) | |
589 | { | |
590 | fprintf( stderr, "failed!\n" ); | |
591 | return; | |
592 | } /*if*/ | |
593 | else | |
594 | fprintf( stderr, "\n" ); | |
595 | ||
596 | ||
597 | sprintf( buffer, "SDD_LAYER%i_LADDER%02d_MODULE%d_HV", iLay, iLad, iMod ); | |
598 | TObjArray* arrHV = (TObjArray*) map->GetValue( buffer ); | |
599 | if( arrHV == NULL ) | |
600 | { | |
601 | fprintf( stderr, "Map record %s does not exist!\n", buffer ); | |
602 | nHVEntries = 0; | |
603 | } | |
604 | else | |
605 | nHVEntries = arrHV->GetEntries(); | |
606 | ||
607 | sprintf( buffer, "SDD_LAYER%i_LADDER%02d_MODULE%d_MV", iLay, iLad, iMod ); | |
608 | TObjArray* arrMV = (TObjArray*) map->GetValue( buffer ); | |
609 | if( arrMV == NULL ) | |
610 | { | |
611 | fprintf( stderr, "Map record %s does not exist!\n", buffer ); | |
612 | nMVEntries = 0; | |
613 | } | |
614 | else | |
615 | nMVEntries = arrMV->GetEntries(); | |
616 | ||
617 | sprintf( buffer, "SDD_LAYER%i_LADDER%02d_MODULE%d_TEMP_L", iLay, iLad, iMod ); | |
618 | TObjArray* arrTL = (TObjArray*) map->GetValue( buffer ); | |
619 | if( arrTL == NULL ) | |
620 | { | |
621 | fprintf( stderr, "Map record %s does not exist!\n", buffer ); | |
622 | nTLEntries = 0; | |
623 | } | |
624 | else | |
625 | nTLEntries = arrTL->GetEntries(); | |
626 | ||
627 | sprintf( buffer, "SDD_LAYER%i_LADDER%02d_MODULE%d_TEMP_R", iLay, iLad, iMod ); | |
628 | TObjArray* arrTR = (TObjArray*) map->GetValue( buffer ); | |
629 | if( arrTR == NULL ) | |
630 | { | |
631 | fprintf( stderr, "Map record %s does not exist!\n", buffer ); | |
632 | nTREntries = 0; | |
633 | } | |
634 | else | |
635 | nTREntries = arrTR->GetEntries(); | |
636 | ||
637 | sprintf( buffer, "SDD_LAYER%i_LADDER%02d_MODULE%d_TEMP_L_STATE", iLay, iLad, iMod ); | |
638 | TObjArray* arrStTL = (TObjArray*) map->GetValue( buffer ); | |
639 | if( arrStTL == NULL ) | |
640 | { | |
641 | fprintf( stderr, "Map record %s does not exist!\n", buffer ); | |
642 | nStTLEntries = 0; | |
643 | } | |
644 | else | |
645 | nStTLEntries = arrStTL->GetEntries(); | |
646 | ||
647 | sprintf( buffer, "SDD_LAYER%i_LADDER%02d_MODULE%d_TEMP_R_STATE", iLay, iLad, iMod ); | |
648 | TObjArray* arrStTR = (TObjArray*) map->GetValue( buffer ); | |
649 | if( arrStTR == NULL ) | |
650 | { | |
651 | fprintf( stderr, "Map record %s does not exist!\n", buffer ); | |
652 | nStTREntries = 0; | |
653 | } | |
654 | else | |
655 | nStTREntries = arrStTR->GetEntries(); | |
656 | ||
657 | sprintf( buffer, "SDD_LAYER%i_LADDER%02d_MODULE%d_OK", iLay, iLad, iMod ); | |
658 | TObjArray* arrOK = (TObjArray*) map->GetValue( buffer ); | |
659 | if( arrOK == NULL ) | |
660 | { | |
661 | fprintf( stderr, "Map record %s does not exist!\n", buffer ); | |
662 | nOKEntries = 0; | |
663 | } | |
664 | else | |
665 | nOKEntries = arrOK->GetEntries(); | |
666 | ||
667 | fprintf( outputFile, "+-----------------------------------------------------------------------"); | |
668 | fprintf( outputFile, "------------------------------------------------------------------------+\n" ); | |
669 | fprintf( outputFile, "| DCS Map content for SDD_LAYER%i_LADDER%02d_MODULE%d" , iLay, iLad, iMod); | |
670 | fprintf( outputFile, " |\n" ); | |
671 | fprintf( outputFile, "+----------------------+----------------------+---------------------+----------------------+"); | |
672 | fprintf( outputFile, "-----------------+-----------------+----------------+\n" ); | |
673 | fprintf( outputFile, "| %05i records | %05i records | %05i records | %05i records | %05i records |", | |
674 | nHVEntries, nMVEntries, nTLEntries, nTREntries, nStTLEntries ); | |
675 | fprintf( outputFile, " %05i records | %05i records |\n", nStTREntries, nOKEntries ); | |
676 | ||
dc5eacf8 | 677 | fprintf( outputFile, "| time (s) HV | time (s) MV | time (s) TL | time (s) TR | time (s) StTL |" ); |
e22bf775 | 678 | fprintf( outputFile, " time (s) StTR | time (s) OK |\n" ); |
679 | fprintf( outputFile, "+----------------------+----------------------+---------------------+---------------------+"); | |
680 | fprintf( outputFile, "-----------------+-----------------+-----------------+\n" ); | |
681 | ||
682 | ||
683 | ||
684 | Int_t a = (nHVEntries > nMVEntries ) ? nHVEntries : nMVEntries; | |
685 | Int_t b = (nTLEntries > nTREntries ) ? nTLEntries : nTREntries; | |
686 | Int_t c = (nStTLEntries > nStTREntries ) ? nStTLEntries : nStTREntries; | |
687 | if( a < b ) a = b; if( c < nOKEntries ) c = nOKEntries; | |
688 | Int_t loopMax = ( a > c ) ? a : c ; | |
689 | // Finds maximal entry number | |
690 | ||
691 | ||
692 | ||
693 | for( Int_t entryLoop = 0; entryLoop < loopMax; entryLoop++ ) | |
694 | { | |
695 | ||
696 | if( entryLoop < nHVEntries ) | |
697 | fprintf( outputFile, "| %12i %4.2f | ", ((AliDCSValue*)arrHV->At(entryLoop))->GetTimeStamp(), | |
698 | ((AliDCSValue*)arrHV->At(entryLoop))->GetFloat() ); | |
699 | else | |
700 | fprintf( outputFile, "| | "); | |
701 | ||
702 | if( entryLoop < nMVEntries ) | |
dc5eacf8 | 703 | fprintf( outputFile, " %12i %2.3f | ", ((AliDCSValue*)arrMV->At(entryLoop))->GetTimeStamp(), |
e22bf775 | 704 | ((AliDCSValue*)arrMV->At(entryLoop))->GetFloat() ); |
705 | else | |
dc5eacf8 | 706 | fprintf( outputFile, " | "); |
e22bf775 | 707 | |
708 | if( entryLoop < nTLEntries ) | |
709 | fprintf( outputFile, "%12i %2.2f | ", ((AliDCSValue*)arrTL->At(entryLoop))->GetTimeStamp(), | |
710 | ((AliDCSValue*)arrTL->At(entryLoop))->GetFloat() ); | |
711 | else | |
712 | fprintf( outputFile, " | "); | |
713 | ||
714 | if( entryLoop < nTREntries ) | |
715 | fprintf( outputFile, "%12i %2.2f | ", ((AliDCSValue*)arrTR->At(entryLoop))->GetTimeStamp(), | |
716 | ((AliDCSValue*)arrTR->At(entryLoop))->GetFloat() ); | |
717 | else | |
718 | fprintf( outputFile, " | "); | |
719 | ||
720 | if( entryLoop < nStTLEntries ) | |
721 | fprintf( outputFile, "%12i %i | ", ((AliDCSValue*)arrStTL->At(entryLoop))->GetTimeStamp(), | |
722 | ((AliDCSValue*)arrStTL->At(entryLoop))->GetInt() ); | |
723 | else | |
724 | fprintf( outputFile, " | "); | |
725 | ||
726 | if( entryLoop < nStTREntries ) | |
727 | fprintf( outputFile, "%12i %i | ", ((AliDCSValue*)arrStTR->At(entryLoop))->GetTimeStamp(), | |
728 | ((AliDCSValue*)arrStTR->At(entryLoop))->GetInt() ); | |
729 | else | |
730 | fprintf( outputFile, " | "); | |
731 | ||
732 | if( entryLoop < nOKEntries ) | |
733 | fprintf( outputFile, "%12i %i |\n", ((AliDCSValue*)arrOK->At(entryLoop))->GetTimeStamp(), | |
734 | ((AliDCSValue*)arrOK->At(entryLoop))->GetBool() ); | |
735 | else | |
736 | fprintf( outputFile, " |\n"); | |
737 | ||
738 | } /*for( entryLoop )*/ | |
739 | ||
740 | fclose( outputFile ); | |
741 | ||
742 | ||
743 | } /*for(iMod)*/ | |
744 | ||
745 | ||
746 | } /*for(iLad)*/ | |
747 | } /*for(iLay)*/ | |
748 | ||
749 | ||
750 | } /*GenerateOutputFiles*/ |