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 //---------------------------------------------------------------------------