Fixing a little overlap. Adding flags to perform material budget studies (Mario)
[u/mrichter/AliRoot.git] / ITS / AliITSDCSDataSDD.cxx
1 /**************************************************************************
2  * Copyright(c) 2007-2009, ALICE Experiment at CERN, All rights reserved. *
3  *                                                                        *
4  * Author: The ALICE Off-line Project.                                    *
5  * Contributors are mentioned in the code where appropriate.              *
6  *                                                                        *
7  * Permission to use, copy, modify and distribute this software and its   *
8  * documentation strictly for non-commercial purposes is hereby granted   *
9  * without fee, provided that the above copyright notice appears in all   *
10  * copies and that both the copyright notice and this permission notice   *
11  * appear in the supporting documentation. The authors make no claims     *
12  * about the suitability of this software for any purpose. It is          *
13  * provided "as is" without express or implied warranty.                  *
14  **************************************************************************/
15
16 /* $Id$ */
17
18 ///////////////////////////////////////////////////////////////////
19 // Implementation of the class containing SDD DCS data           //
20 // Origin: F.Prino, Torino, prino@to.infn.it                     //
21 //         V. Pospisil, CTU Praguem gdermog@seznam.cz            //
22 ///////////////////////////////////////////////////////////////////
23
24 #include "AliITSDCSDataSDD.h"
25 #include "AliLog.h"
26
27 #define AUTORESIZE 50
28
29 ClassImp(AliITSDCSDataSDD)
30
31 const Float_t AliITSDCSDataSDD::fgkTPrec = 100.0;
32 const Float_t AliITSDCSDataSDD::fgkMVPrec = 1000.0;
33
34 //---------------------------------------------------------------------------
35 AliITSDCSDataSDD::AliITSDCSDataSDD(): TObject(),
36 fTempLeft(0),
37 fTempLeftTimeStamp(0),
38 fTempLeftMaxPoints(0),
39 fTempLeftSetPoints(0),
40 fTempRight(0),
41 fTempRightTimeStamp(0),
42 fTempRightMaxPoints(0),
43 fTempRightSetPoints(0),
44 fHV(0),
45 fHVTimeStamp(0),
46 fHVMaxPoints(0),
47 fHVSetPoints(0),
48 fMV(0),
49 fMVTimeStamp(0),
50 fMVMaxPoints(0),
51 fMVSetPoints(0),
52 fStatus(0),
53 fStatusTimeStamp(0),
54 fStatusMaxPoints(0),
55 fStatusSetPoints(0)
56 {
57 // default constructor
58 } /*AliITSDCSDataSDD::AliITSDCSDataSDD*/
59
60 //---------------------------------------------------------------------------
61
62 void AliITSDCSDataSDD::SetNPointsTempLeft( Int_t npts )
63 {
64   // dimension arrays with left side temperatures
65   //
66
67   if( npts < fTempLeftSetPoints)
68   {                     // Cannot resize arrays - some elements would be lost
69     AliWarning("Attemp to reduce size of full array (SDD DCS _TEMP_L)"); 
70     return;
71   } /*if*/
72
73   fTempLeft.Set( npts );
74   fTempLeftTimeStamp.Set( npts );
75                         // Both temperature and tme stamp arrays are resized
76
77   fTempLeftMaxPoints = npts;
78                         // New size is stored
79 } /*AliITSDCSDataSDD::SetNPointsTempLeft*/
80
81 //---------------------------------------------------------------------------
82
83 void AliITSDCSDataSDD::SetNPointsTempRight( Int_t npts )
84 {
85   // dimension arrays with right side temperatures
86   //
87
88   if( npts < fTempRightSetPoints)
89   {                     // Cannot resize arrays - some elements would be lost
90     AliWarning("Attemp to reduce size of full array (SDD DCS _TEMP_R)");
91     return;
92   } /*if*/
93
94   fTempRight.Set( npts );
95   fTempRightTimeStamp.Set( npts );
96                         // Both temperature and tme stamp arrays are resized
97
98   fTempRightMaxPoints = npts;
99                         // New size is stored
100 } /*AliITSDCSDataSDD::SetNPointsTempRight*/
101
102 //---------------------------------------------------------------------------
103
104 void AliITSDCSDataSDD::SetNPointsHV( Int_t npts )
105 {
106   // dimension arrays with HV values
107   //
108
109   if( npts < fHVSetPoints)
110   {                     // Cannot resize arrays - some elements would be lost
111     AliWarning("Attemp to reduce size of full array (SDD DCS _HV)");
112     return;
113   } /*if*/
114
115   fHV.Set( npts );
116   fHVTimeStamp.Set( npts );
117                         // Both temperature and tme stamp arrays are resized
118
119   fHVMaxPoints = npts;  // New size is stored
120
121 }/*AliITSDCSDataSDD::SetNPointsHV*/
122
123 //---------------------------------------------------------------------------
124
125 void AliITSDCSDataSDD::SetNPointsMV( Int_t npts )
126 {
127   // dimension arrays with   MV values
128   //
129
130   if( npts < fMVSetPoints)
131   {                     // Cannot resize arrays - some elements would be lost
132     AliWarning("Attemp to reduce size of full array (SDD DCS _MV)");
133     return;
134   } /*if*/
135
136   fMV.Set( npts );
137   fMVTimeStamp.Set( npts );
138                         // Both temperature and tme stamp arrays are resized
139
140   fMVMaxPoints = npts;  // New size is stored 
141
142 } /*AliITSDCSDataSDD::SetNPointsMV*/
143
144 //---------------------------------------------------------------------------
145
146 void AliITSDCSDataSDD::SetNPointsStatus( Int_t npts )
147 {
148   // dimension arrays withn DCS channel status
149   //
150
151   if( npts < fStatusSetPoints)
152   {                     // Cannot resize arrays - some elements would be lost
153     AliWarning("Attemp to reduce size of full array (SDD DCS Status)");
154     return;
155   } /*if*/
156
157   fStatus.Set( npts );
158   fStatusTimeStamp.Set( npts );
159                         // Both temperature and tme stamp arrays are resized
160
161   fStatusMaxPoints = npts;
162                         // New size is stored 
163
164 } /*AliITSDCSDataSDD::SetNPointsMV*/
165
166 //---------------------------------------------------------------------------
167 void AliITSDCSDataSDD::SetValueTempLeft(Int_t time, Float_t temperature )
168 {
169   // insert a value for left temperature data point
170   //
171
172    if( fTempLeftMaxPoints == fTempLeftSetPoints )
173     SetNPointsTempLeft( fTempLeftMaxPoints + AUTORESIZE );
174                         // Enlarges arrays if necessary
175
176    Int_t i =  FindIndex( time, fTempLeftTimeStamp, fTempLeftSetPoints );
177                         // Finds place where the new value have to be inserted
178
179    if( i < 0 )
180     i = 0;              // New value have to be inserted before the first one in the array
181    else
182     i++;                // New value will be put somewhere in the middle of the array
183                         //  or at the end
184
185    if( i < fTempLeftSetPoints )
186    {
187       Short_t *fromPtrF = fTempLeft.GetArray() + i;
188                        // Sets pointer to cell which have to be filled by new value
189       Short_t *toPtrF = fromPtrF + 1;
190                        // Sets pointer to cell where the array content have to be shifted 
191
192       memmove( toPtrF, fromPtrF, (fTempLeftSetPoints - i)*sizeof(Short_t) );
193                        // Shifts array content. Now there is vacant place for new value to be inserted
194
195       Int_t *fromPtrI = fTempLeftTimeStamp.GetArray() + i;
196       Int_t *toPtrI = fromPtrI + 1;
197       memmove( toPtrI, fromPtrI, (fTempLeftSetPoints - i)*sizeof(Int_t) );
198                        // Do the same for time stamp array
199    } /*if*/
200
201    UShort_t val = (UShort_t)( temperature * fgkTPrec );
202                        // Float value of temperature is stored as UShort_t with given precision
203
204    fTempLeft.AddAt( (Short_t)val, i );
205    fTempLeftTimeStamp.AddAt( time, i );
206    fTempLeftSetPoints++;
207                        // New values are inserted
208 } /*AliITSDCSDataSDD::SetValueTempLeft*/
209
210 //---------------------------------------------------------------------------
211
212 void AliITSDCSDataSDD::SetValueTempRight(Int_t time, Float_t temperature )
213 {
214   // insert a value for right temperature data point
215   //
216
217    if( fTempRightMaxPoints == fTempRightSetPoints )
218     SetNPointsTempRight( fTempRightMaxPoints + AUTORESIZE );
219                         // Enlarges arrays if necessary
220
221    Int_t i =  FindIndex( time, fTempRightTimeStamp, fTempRightSetPoints );
222                         // Finds place where the new value have to be inserted
223
224    if( i < 0 )
225     i = 0;              // New value have to be inserted before the first one in the array
226    else
227     i++;                // New value will be put somewhere in the middle of the array
228                         //  or at the end
229
230    if( i < fTempRightSetPoints )
231    {                    // Some values have to be moved
232       Short_t *fromPtrF = fTempRight.GetArray() + i;
233                        // Sets pointer to cell which have to be filled by new value
234       Short_t *toPtrF = fromPtrF + 1;
235                        // Sets pointer to cell where the array content have to be shifted 
236
237       memmove( toPtrF, fromPtrF, (fTempRightSetPoints - i)*sizeof(Short_t) );
238                        // Shifts array content. Now there is vacant place for new value to be inserted
239
240       Int_t *fromPtrI = fTempRightTimeStamp.GetArray() + i;
241       Int_t *toPtrI = fromPtrI + 1;
242       memmove( toPtrI, fromPtrI, (fTempRightSetPoints - i)*sizeof(Int_t) );
243                        // Do the same for time stamp array
244    } /*if*/
245
246    UShort_t val = (UShort_t)( temperature * fgkTPrec );
247                        // Float value of temperature is stored as UShort_t with given precision
248
249    fTempRight.AddAt( (Short_t)val, i );
250    fTempRightTimeStamp.AddAt( time, i );
251    fTempRightSetPoints++;
252                        // New values are inserted
253 } /*AliITSDCSDataSDD::SetValueTempRight*/
254
255 //---------------------------------------------------------------------------
256
257 void AliITSDCSDataSDD::SetValueHV(Int_t time, Float_t voltage )
258 {
259   // insert a value for HV data point
260   //
261
262    if( fHVMaxPoints == fHVSetPoints )
263     SetNPointsHV( fHVMaxPoints + AUTORESIZE );
264                         // Enlarges arrays if necessary
265
266    Int_t i =  FindIndex( time, fHVTimeStamp, fHVSetPoints );
267                         // Finds place where the new value have to be inserted
268
269    if( i < 0 )
270     i = 0;              // New value have to be inserted before the first one in the array
271    else
272     i++;                // New value will be put somewhere in the middle of the array
273                         //  or at the end
274
275    if( i < fHVSetPoints )
276    {
277       Float_t *fromPtrF = fHV.GetArray() + i;
278                        // Sets pointer to cell which have to be filled by new value
279       Float_t *toPtrF = fromPtrF + 1;
280                        // Sets pointer to cell where the array content have to be shifted 
281
282       memmove( toPtrF, fromPtrF, (fHVSetPoints - i)*sizeof(Float_t) );
283                        // Shifts array content. Now there is vacant place for new value to be inserted
284
285       Int_t *fromPtrI = fHVTimeStamp.GetArray() + i;
286       Int_t *toPtrI = fromPtrI + 1;
287       memmove( toPtrI, fromPtrI, (fHVSetPoints - i)*sizeof(Int_t) );
288                        // Do the same for time stamp array
289    } /*if*/
290
291    fHV.AddAt( voltage, i );
292    fHVTimeStamp.AddAt( time, i );
293    fHVSetPoints++;
294                        // New values are inserted
295 } /*AliITSDCSDataSDD::SetValueHV*/
296
297 //---------------------------------------------------------------------------
298
299 void AliITSDCSDataSDD::SetValueMV(Int_t time, Float_t voltage )
300 {
301   // insert a value for MV data point
302   //
303
304    if( fMVMaxPoints == fMVSetPoints )
305     SetNPointsMV( fMVMaxPoints + AUTORESIZE );
306                         // Enlarges arrays if necessary
307
308    Int_t i =  FindIndex( time, fMVTimeStamp, fMVSetPoints );
309                         // Finds place where the new value have to be inserted
310
311    if( i < 0 )
312     i = 0;              // New value have to be inserted before the first one in the array
313    else
314     i++;                // New value will be put somewhere in the middle of the array
315                         //  or at the end
316
317    if( i < fMVSetPoints )
318    {
319       Short_t *fromPtrF = fMV.GetArray() + i;
320                        // Sets pointer to cell which have to be filled by new value
321       Short_t *toPtrF = fromPtrF + 1;
322                        // Sets pointer to cell where the array content have to be shifted 
323
324       memmove( toPtrF, fromPtrF, (fMVSetPoints - i)*sizeof(Short_t) );
325                        // Shifts array content. Now there is vacant place for new value to be inserted
326
327       Int_t *fromPtrI = fMVTimeStamp.GetArray() + i;
328       Int_t *toPtrI = fromPtrI + 1;
329       memmove( toPtrI, fromPtrI, (fMVSetPoints - i)*sizeof(Int_t) );
330                        // Do the same for time stamp array
331    } /*if*/
332
333    UShort_t val = (UShort_t)( voltage * fgkMVPrec );
334                        // Float value of temperature is stored as UShort_t with given precision
335
336    fMV.AddAt( (Short_t)val, i );
337    fMVTimeStamp.AddAt( time, i );
338    fMVSetPoints++;
339                        // New values are inserted
340 } /*AliITSDCSDataSDD::SetValueMV*/
341
342 //---------------------------------------------------------------------------
343
344 void AliITSDCSDataSDD::SetValueStatus(Int_t time, Char_t status )
345 {
346   // insert a value for channel status
347   //
348
349    if( fStatusMaxPoints == fStatusSetPoints )
350     SetNPointsStatus( fStatusMaxPoints + AUTORESIZE );
351                         // Enlarges arrays if necessary
352
353    Int_t i =  FindIndex( time, fStatusTimeStamp, fStatusSetPoints );
354                         // Finds place where the new value have to be inserted
355
356    if( i < 0 )
357     i = 0;              // New value have to be inserted before the first one in the array
358    else
359     i++;                // New value will be put somewhere in the middle of the array
360                         //  or at the end
361
362    if( i < fStatusSetPoints )
363    {
364       Char_t *fromPtrF = fStatus.GetArray() + i;
365                        // Sets pointer to cell which have to be filled by new value
366       Char_t *toPtrF = fromPtrF + 1;
367                        // Sets pointer to cell where the array content have to be shifted 
368
369       memmove( toPtrF, fromPtrF, (fStatusSetPoints - i)*sizeof(Char_t) );
370                        // Shifts array content. Now there is vacant place for new value to be inserted
371
372       Int_t *fromPtrI = fStatusTimeStamp.GetArray() + i;
373       Int_t *toPtrI = fromPtrI + 1;
374       memmove( toPtrI, fromPtrI, (fStatusSetPoints - i)*sizeof(Int_t) );
375                        // Do the same for time stamp array
376    } /*if*/
377
378    fStatus.AddAt( status, i );
379    fStatusTimeStamp.AddAt( time, i );
380    fStatusSetPoints++;
381                        // New values are inserted
382
383 } /*AliITSDCSDataSDD::SetValueStatus*/
384
385
386 //---------------------------------------------------------------------------
387
388 void AliITSDCSDataSDD::Compress()
389 {
390 // Minimize array sizes
391
392    SetNPointsTempLeft( fTempLeftSetPoints );
393    SetNPointsTempRight( fTempRightSetPoints );
394    SetNPointsHV( fHVSetPoints );
395    SetNPointsMV( fMVSetPoints );
396    SetNPointsStatus( fStatusSetPoints );
397
398 } /*AliITSDCSDataSDD::Compress*/
399
400 //---------------------------------------------------------------------------
401
402 Float_t AliITSDCSDataSDD::GetDriftField( Int_t timeStamp ) const
403 {
404 // Returns drift field counted for specific time
405
406    Int_t   cathodesNumber = 291;
407    Float_t cathodesPitch = 0.0120;
408
409    Float_t hv = GetHV( timeStamp );
410    Float_t mv = GetMV( timeStamp );
411
412    if( hv < 0.0 || mv < 0.0 ) return -1.0;
413                         // HV or MV is unknown at this time
414
415    return ( hv - mv ) / ( cathodesNumber * cathodesPitch );
416
417 } /*AliITSDCSDataSDD::GetDriftField*/
418
419 //---------------------------------------------------------------------------
420
421
422 Float_t AliITSDCSDataSDD::GetDriftSpeed( Int_t /*timeStamp*/ ) const
423 {
424 // Returns drift speed counted for specific time. Calculation is based on temerature
425 //  taken  from DCS. This metod is not dedicated for normal usage, it should be used
426 //  only in cases that the injectors for given module fails.
427 //
428 // Presently only a prototype, returns -1.0.
429
430    /* PROTOTYPE */
431
432    return -1.0;
433
434 } /*AliITSDCSDataSDD::*/
435
436 //---------------------------------------------------------------------------
437
438
439 void AliITSDCSDataSDD:: PrintValues( FILE *output ) const
440 {
441 // Prints array contents
442
443     Int_t nTLEntries = GetTempLeftRecords();
444     Int_t nTREntries = GetTempRightRecords();
445     Int_t nHVEntries = GetHVRecords() ;
446     Int_t nMVEntries = GetMVRecords();
447     Int_t nStatEntries = GetStatusRecords();
448
449     fprintf( output, "+------------------------------------------------------------------------------------------------------------+\n");
450     fprintf( output, "|                                                DCS content                                                 |\n" ); 
451     fprintf( output, "+----------------------+-----------------------+---------------------+---------------------+-----------------+\n");
452     fprintf( output, "|    %05i  records    |    %05i   records    |    %05i  records   |    %05i  records   |  %05i records  |\n",
453                           nHVEntries, nMVEntries, nTLEntries, nTREntries, nStatEntries );
454     fprintf( output, "|  time (s)     HV     |  time (s)      MV     |  time (s)     TL    |  time (s)     TR    | time (s)   Stat |\n" );
455     fprintf( output, "+----------------------+-----------------------+---------------------+---------------------+-----------------+\n");
456
457     Int_t a = (nHVEntries > nMVEntries ) ? nHVEntries : nMVEntries;
458     Int_t b = (nTLEntries > nTREntries ) ? nTLEntries : nTREntries;
459     if( a < b ) a = b;
460     Int_t loopMax = ( a > nStatEntries ) ? a : nStatEntries ;
461                  // Finds maximal entry number
462
463     for( Int_t entryLoop = 0; entryLoop < loopMax; entryLoop++ )
464     {
465
466         if( entryLoop < nHVEntries )
467          fprintf( output, "| %12i %4.2f | ", GetHVTimeIdx(entryLoop), GetHVIdx(entryLoop) );
468         else
469          fprintf( output, "|                      | ");
470
471         if( entryLoop < nMVEntries )
472          fprintf( output, " %12i  %2.3f | ", GetMVTimeIdx(entryLoop), GetMVIdx(entryLoop) );
473         else
474          fprintf( output, "                      | ");
475
476         if( entryLoop < nTLEntries )
477          fprintf( output, "%12i  %2.2f | ", GetTempLeftTimeIdx(entryLoop), GetTempLeftIdx(entryLoop) );
478         else
479          fprintf( output, "                    | ");
480
481         if( entryLoop < nTREntries )
482          fprintf( output, "%12i  %2.2f | ", GetTempRightTimeIdx(entryLoop), GetTempRightIdx(entryLoop) );
483         else
484          fprintf( output, "                    | ");
485
486         if( entryLoop < nStatEntries )
487          fprintf( output, "%12i  %i |\n", GetStatusTimeIdx(entryLoop), GetStatusIdx(entryLoop) );
488         else
489          fprintf( output, "                |\n");
490
491     } /*for( entryLoop )*/
492
493
494 } /*AliITSDCSDataSDD::PrintValues()*/
495
496 //---------------------------------------------------------------------------
497
498 Int_t AliITSDCSDataSDD::FindIndex( Int_t timeStamp, const TArrayI &timeStampArray, Int_t n ) const
499 {
500 // Provides binary search in the time array. Returns index in the array of time 
501 //  stamps by selected value. Returns -1 if the time is less than time stamp in 
502 //  the timeArray[0]
503
504   if( n < 1 ) return -1;// Empty array or wrong value of array size
505
506   if( timeStamp >= timeStampArray.At(n-1) ) return n-1;
507                         // Time is larger than last timestamp - last value in the array have
508                         //  to be used. This is the most frequent case, so it have sense
509                         //  to check it and avoid searching.
510
511   if( timeStamp < timeStampArray.At(0) ) return -1;
512                         // Time is less than all time stamp stored in the array
513
514   Int_t left = 0;
515   Int_t right = n-1;
516   Int_t middle = (left + right)/2;
517
518   while( !( middle == left || middle == right) )
519   {                     // Binary search in the time stamp array
520
521      if( timeStampArray.At(middle) < timeStamp )
522       left = middle;
523      else
524       right = middle;
525      middle = (left + right)/2;
526   } /*while*/
527
528   if( timeStamp >= timeStampArray.At(right) )
529    return right;
530   else
531    return left;
532
533 } /*AliITSDCSDataSDD::FindIndexByTimeStamp*/
534
535 //---------------------------------------------------------------------------