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   //
  65   if( npts < fTempLeftSetPoints)
  66   {                     // Cannot resize arrays - some elements would be lost
  67     AliWarning("Attemp to reduce size of full array (SDD DCS _TEMP_L)");
  68     return;
  69   } /*if*/
  70
  71   fTempLeft.Set( npts );
  72   fTempLeftTimeStamp.Set( npts );
  73                         // Both temperature and tme stamp arrays are resized
  74
  75   fTempLeftMaxPoints = npts;
  76                         // New size is stored
  77 } /*AliITSDCSDataSDD::SetNPointsTempLeft*/
  78
  79 //---------------------------------------------------------------------------
  80
  81 void AliITSDCSDataSDD::SetNPointsTempRight( Int_t npts )
  82 {
  83   //
  84   if( npts < fTempRightSetPoints)
  85   {                     // Cannot resize arrays - some elements would be lost
  86     AliWarning("Attemp to reduce size of full array (SDD DCS _TEMP_R)");
  87     return;
  88   } /*if*/
  89
  90   fTempRight.Set( npts );
  91   fTempRightTimeStamp.Set( npts );
  92                         // Both temperature and tme stamp arrays are resized
  93
  94   fTempRightMaxPoints = npts;
  95                         // New size is stored
  96 } /*AliITSDCSDataSDD::SetNPointsTempRight*/
  97
  98 //---------------------------------------------------------------------------
  99
 100 void AliITSDCSDataSDD::SetNPointsHV( Int_t npts )
 101 {
 102   //
 103   if( npts < fHVSetPoints)
 104   {                     // Cannot resize arrays - some elements would be lost
 105     AliWarning("Attemp to reduce size of full array (SDD DCS _HV)");
 106     return;
 107   } /*if*/
 108
 109   fHV.Set( npts );
 110   fHVTimeStamp.Set( npts );
 111                         // Both temperature and tme stamp arrays are resized
 112
 113   fHVMaxPoints = npts;  // New size is stored
 114
 115 }/*AliITSDCSDataSDD::SetNPointsHV*/
 116
 117 //---------------------------------------------------------------------------
 118
 119 void AliITSDCSDataSDD::SetNPointsMV( Int_t npts )
 120 {
 121   //
 122   if( npts < fMVSetPoints)
 123   {                     // Cannot resize arrays - some elements would be lost
 124     AliWarning("Attemp to reduce size of full array (SDD DCS _MV)");
 125     return;
 126   } /*if*/
 127
 128   fMV.Set( npts );
 129   fMVTimeStamp.Set( npts );
 130                         // Both temperature and tme stamp arrays are resized
 131
 132   fMVMaxPoints = npts;  // New size is stored
 133
 134 } /*AliITSDCSDataSDD::SetNPointsMV*/
 135
 136 //---------------------------------------------------------------------------
 137
 138 void AliITSDCSDataSDD::SetNPointsStatus( Int_t npts )
 139 {
 140   //
 141   if( npts < fStatusSetPoints)
 142   {                     // Cannot resize arrays - some elements would be lost
 143     AliWarning("Attemp to reduce size of full array (SDD DCS Status)");
 144     return;
 145   } /*if*/
 146
 147   fStatus.Set( npts );
 148   fStatusTimeStamp.Set( npts );
 149                         // Both temperature and tme stamp arrays are resized
 150
 151   fStatusMaxPoints = npts;
 152                         // New size is stored
 153
 154 } /*AliITSDCSDataSDD::SetNPointsMV*/
 155
 156 //---------------------------------------------------------------------------
 157 void AliITSDCSDataSDD::SetValueTempLeft(Int_t time, Float_t temperature )
 158 {
 159   //
 160    if( fTempLeftMaxPoints == fTempLeftSetPoints )
 161     SetNPointsTempLeft( fTempLeftMaxPoints + AUTORESIZE );
 162                         // Enlarges arrays if necessary
 163
 164    Int_t i =  FindIndex( time, fTempLeftTimeStamp, fTempLeftSetPoints );
 165                         // Finds place where the new value have to be inserted
 166
 167    if( i < 0 )
 168     i = 0;              // New value have to be inserted before the first one in the array
 169    else
 170     i++;                // New value will be put somewhere in the middle of the array
 171                         //  or at the end
 172
 173    if( i < fTempLeftSetPoints )
 174    {
 175       Short_t *fromPtrF = fTempLeft.GetArray() + i;
 176                        // Sets pointer to cell which have to be filled by new value
 177       Short_t *toPtrF = fromPtrF + 1;
 178                        // Sets pointer to cell where the array content have to be shifted
 179
 180       memmove( toPtrF, fromPtrF, (fTempLeftSetPoints - i)*sizeof(Short_t) );
 181                        // Shifts array content. Now there is vacant place for new value to be inserted
 182
 183       Int_t *fromPtrI = fTempLeftTimeStamp.GetArray() + i;
 184       Int_t *toPtrI = fromPtrI + 1;
 185       memmove( toPtrI, fromPtrI, (fTempLeftSetPoints - i)*sizeof(Int_t) );
 186                        // Do the same for time stamp array
 187    } /*if*/
 188
 189    UShort_t val = (UShort_t)( temperature * fgkTPrec );
 190                        // Float value of temperature is stored as UShort_t with given precision
 191
 192    fTempLeft.AddAt( (Short_t)val, i );
 193    fTempLeftTimeStamp.AddAt( time, i );
 194    fTempLeftSetPoints++;
 195                        // New values are inserted
 196 } /*AliITSDCSDataSDD::SetValueTempLeft*/
 197
 198 //---------------------------------------------------------------------------
 199
 200 void AliITSDCSDataSDD::SetValueTempRight(Int_t time, Float_t temperature )
 201 {
 202   //
 203    if( fTempRightMaxPoints == fTempRightSetPoints )
 204     SetNPointsTempRight( fTempRightMaxPoints + AUTORESIZE );
 205                         // Enlarges arrays if necessary
 206
 207    Int_t i =  FindIndex( time, fTempRightTimeStamp, fTempRightSetPoints );
 208                         // Finds place where the new value have to be inserted
 209
 210    if( i < 0 )
 211     i = 0;              // New value have to be inserted before the first one in the array
 212    else
 213     i++;                // New value will be put somewhere in the middle of the array
 214                         //  or at the end
 215
 216    if( i < fTempRightSetPoints )
 217    {                    // Some values have to be moved
 218       Short_t *fromPtrF = fTempRight.GetArray() + i;
 219                        // Sets pointer to cell which have to be filled by new value
 220       Short_t *toPtrF = fromPtrF + 1;
 221                        // Sets pointer to cell where the array content have to be shifted
 222
 223       memmove( toPtrF, fromPtrF, (fTempRightSetPoints - i)*sizeof(Short_t) );
 224                        // Shifts array content. Now there is vacant place for new value to be inserted
 225
 226       Int_t *fromPtrI = fTempRightTimeStamp.GetArray() + i;
 227       Int_t *toPtrI = fromPtrI + 1;
 228       memmove( toPtrI, fromPtrI, (fTempRightSetPoints - i)*sizeof(Int_t) );
 229                        // Do the same for time stamp array
 230    } /*if*/
 231
 232    UShort_t val = (UShort_t)( temperature * fgkTPrec );
 233                        // Float value of temperature is stored as UShort_t with given precision
 234
 235    fTempRight.AddAt( (Short_t)val, i );
 236    fTempRightTimeStamp.AddAt( time, i );
 237    fTempRightSetPoints++;
 238                        // New values are inserted
 239 } /*AliITSDCSDataSDD::SetValueTempRight*/
 240
 241 //---------------------------------------------------------------------------
 242
 243 void AliITSDCSDataSDD::SetValueHV(Int_t time, Float_t voltage )
 244 {
 245   //
 246    if( fHVMaxPoints == fHVSetPoints )
 247     SetNPointsHV( fHVMaxPoints + AUTORESIZE );
 248                         // Enlarges arrays if necessary
 249
 250    Int_t i =  FindIndex( time, fHVTimeStamp, fHVSetPoints );
 251                         // Finds place where the new value have to be inserted
 252
 253    if( i < 0 )
 254     i = 0;              // New value have to be inserted before the first one in the array
 255    else
 256     i++;                // New value will be put somewhere in the middle of the array
 257                         //  or at the end
 258
 259    if( i < fHVSetPoints )
 260    {
 261       Float_t *fromPtrF = fHV.GetArray() + i;
 262                        // Sets pointer to cell which have to be filled by new value
 263       Float_t *toPtrF = fromPtrF + 1;
 264                        // Sets pointer to cell where the array content have to be shifted
 265
 266       memmove( toPtrF, fromPtrF, (fHVSetPoints - i)*sizeof(Float_t) );
 267                        // Shifts array content. Now there is vacant place for new value to be inserted
 268
 269       Int_t *fromPtrI = fHVTimeStamp.GetArray() + i;
 270       Int_t *toPtrI = fromPtrI + 1;
 271       memmove( toPtrI, fromPtrI, (fHVSetPoints - i)*sizeof(Int_t) );
 272                        // Do the same for time stamp array
 273    } /*if*/
 274
 275    fHV.AddAt( voltage, i );
 276    fHVTimeStamp.AddAt( time, i );
 277    fHVSetPoints++;
 278                        // New values are inserted
 279 } /*AliITSDCSDataSDD::SetValueHV*/
 280
 281 //---------------------------------------------------------------------------
 282
 283 void AliITSDCSDataSDD::SetValueMV(Int_t time, Float_t voltage )
 284 {
 285   //
 286    if( fMVMaxPoints == fMVSetPoints )
 287     SetNPointsMV( fMVMaxPoints + AUTORESIZE );
 288                         // Enlarges arrays if necessary
 289
 290    Int_t i =  FindIndex( time, fMVTimeStamp, fMVSetPoints );
 291                         // Finds place where the new value have to be inserted
 292
 293    if( i < 0 )
 294     i = 0;              // New value have to be inserted before the first one in the array
 295    else
 296     i++;                // New value will be put somewhere in the middle of the array
 297                         //  or at the end
 298
 299    if( i < fMVSetPoints )
 300    {
 301       Short_t *fromPtrF = fMV.GetArray() + i;
 302                        // Sets pointer to cell which have to be filled by new value
 303       Short_t *toPtrF = fromPtrF + 1;
 304                        // Sets pointer to cell where the array content have to be shifted
 305
 306       memmove( toPtrF, fromPtrF, (fMVSetPoints - i)*sizeof(Short_t) );
 307                        // Shifts array content. Now there is vacant place for new value to be inserted
 308
 309       Int_t *fromPtrI = fMVTimeStamp.GetArray() + i;
 310       Int_t *toPtrI = fromPtrI + 1;
 311       memmove( toPtrI, fromPtrI, (fMVSetPoints - i)*sizeof(Int_t) );
 312                        // Do the same for time stamp array
 313    } /*if*/
 314
 315    UShort_t val = (UShort_t)( voltage * fgkMVPrec );
 316                        // Float value of temperature is stored as UShort_t with given precision
 317
 318    fMV.AddAt( (Short_t)val, i );
 319    fMVTimeStamp.AddAt( time, i );
 320    fMVSetPoints++;
 321                        // New values are inserted
 322 } /*AliITSDCSDataSDD::SetValueMV*/
 323
 324 //---------------------------------------------------------------------------
 325
 326 void AliITSDCSDataSDD::SetValueStatus(Int_t time, Char_t status )
 327 {
 328   //
 329    if( fStatusMaxPoints == fStatusSetPoints )
 330     SetNPointsStatus( fStatusMaxPoints + AUTORESIZE );
 331                         // Enlarges arrays if necessary
 332
 333    Int_t i =  FindIndex( time, fStatusTimeStamp, fStatusSetPoints );
 334                         // Finds place where the new value have to be inserted
 335
 336    if( i < 0 )
 337     i = 0;              // New value have to be inserted before the first one in the array
 338    else
 339     i++;                // New value will be put somewhere in the middle of the array
 340                         //  or at the end
 341
 342    if( i < fStatusSetPoints )
 343    {
 344       Char_t *fromPtrF = fStatus.GetArray() + i;
 345                        // Sets pointer to cell which have to be filled by new value
 346       Char_t *toPtrF = fromPtrF + 1;
 347                        // Sets pointer to cell where the array content have to be shifted
 348
 349       memmove( toPtrF, fromPtrF, (fStatusSetPoints - i)*sizeof(Char_t) );
 350                        // Shifts array content. Now there is vacant place for new value to be inserted
 351
 352       Int_t *fromPtrI = fStatusTimeStamp.GetArray() + i;
 353       Int_t *toPtrI = fromPtrI + 1;
 354       memmove( toPtrI, fromPtrI, (fStatusSetPoints - i)*sizeof(Int_t) );
 355                        // Do the same for time stamp array
 356    } /*if*/
 357
 358    fStatus.AddAt( status, i );
 359    fStatusTimeStamp.AddAt( time, i );
 360    fStatusSetPoints++;
 361                        // New values are inserted
 362
 363 } /*AliITSDCSDataSDD::SetValueStatus*/
 364
 365
 366 //---------------------------------------------------------------------------
 367
 368 void AliITSDCSDataSDD::Compress()
 369 {
 370 // Minimize array sizes
 371
 372    SetNPointsTempLeft( fTempLeftSetPoints );
 373    SetNPointsTempRight( fTempRightSetPoints );
 374    SetNPointsHV( fHVSetPoints );
 375    SetNPointsMV( fMVSetPoints );
 376    SetNPointsStatus( fStatusSetPoints );
 377
 378 } /*AliITSDCSDataSDD::Compress*/
 379
 380 //---------------------------------------------------------------------------
 381
 382 Float_t AliITSDCSDataSDD::GetDriftField( Int_t timeStamp ) const
 383 {
 384 // Returns drift field counted for specific time
 385
 386    Int_t   cathodesNumber = 291;
 387    Float_t cathodesPitch = 0.0120;
 388
 389    Float_t hv = GetHV( timeStamp );
 390    Float_t mv = GetMV( timeStamp );
 391
 392    if( hv < 0.0 || mv < 0.0 ) return -1.0;
 393                         // HV or MV is unknown at this time
 394
 395    return ( hv - mv ) / ( cathodesNumber * cathodesPitch );
 396
 397 } /*AliITSDCSDataSDD::GetDriftField*/
 398
 399 //---------------------------------------------------------------------------
 400
 401
 402 Float_t AliITSDCSDataSDD::GetDriftSpeed( Int_t /*timeStamp*/ ) const
 403 {
 404 // Returns drift speed counted for specific time. Calculation is based on temerature
 405 //  taken  from DCS. This metod is not dedicated for normal usage, it should be used
 406 //  only in cases that the injectors for given module fails.
 407 //
 408 // Presently only a prototype, returns -1.0.
 409
 410    /* PROTOTYPE */
 411
 412    return -1.0;
 413
 414 } /*AliITSDCSDataSDD::*/
 415
 416 //---------------------------------------------------------------------------
 417
 418
 419 void AliITSDCSDataSDD:: PrintValues( FILE *output ) const
 420 {
 421 // Prints array contents
 422
 423     Int_t nTLEntries = GetTempLeftRecords();
 424     Int_t nTREntries = GetTempRightRecords();
 425     Int_t nHVEntries = GetHVRecords() ;
 426     Int_t nMVEntries = GetMVRecords();
 427     Int_t nStatEntries = GetStatusRecords();
 428
 429     fprintf( output, "+------------------------------------------------------------------------------------------------------------+\n");
 430     fprintf( output, "|                                                DCS content                                                 |\n" );
 431     fprintf( output, "+----------------------+-----------------------+---------------------+---------------------+-----------------+\n");
 432     fprintf( output, "|    %05i  records    |    %05i   records    |    %05i  records   |    %05i  records   |  %05i records  |\n",
 433                           nHVEntries, nMVEntries, nTLEntries, nTREntries, nStatEntries );
 434     fprintf( output, "|  time (s)     HV     |  time (s)      MV     |  time (s)     TL    |  time (s)     TR    | time (s)   Stat |\n" );
 435     fprintf( output, "+----------------------+-----------------------+---------------------+---------------------+-----------------+\n");
 436
 437     Int_t a = (nHVEntries > nMVEntries ) ? nHVEntries : nMVEntries;
 438     Int_t b = (nTLEntries > nTREntries ) ? nTLEntries : nTREntries;
 439     if( a < b ) a = b;
 440     Int_t loopMax = ( a > nStatEntries ) ? a : nStatEntries ;
 441                  // Finds maximal entry number
 442
 443     for( Int_t entryLoop = 0; entryLoop < loopMax; entryLoop++ )
 444     {
 445
 446         if( entryLoop < nHVEntries )
 447          fprintf( output, "| %12i %4.2f | ", GetHVTimeIdx(entryLoop), GetHVIdx(entryLoop) );
 448         else
 449          fprintf( output, "|                      | ");
 450
 451         if( entryLoop < nMVEntries )
 452          fprintf( output, " %12i  %2.3f | ", GetMVTimeIdx(entryLoop), GetMVIdx(entryLoop) );
 453         else
 454          fprintf( output, "                      | ");
 455
 456         if( entryLoop < nTLEntries )
 457          fprintf( output, "%12i  %2.2f | ", GetTempLeftTimeIdx(entryLoop), GetTempLeftIdx(entryLoop) );
 458         else
 459          fprintf( output, "                    | ");
 460
 461         if( entryLoop < nTREntries )
 462          fprintf( output, "%12i  %2.2f | ", GetTempRightTimeIdx(entryLoop), GetTempRightIdx(entryLoop) );
 463         else
 464          fprintf( output, "                    | ");
 465
 466         if( entryLoop < nStatEntries )
 467          fprintf( output, "%12i  %i |\n", GetStatusTimeIdx(entryLoop), GetStatusIdx(entryLoop) );
 468         else
 469          fprintf( output, "                |\n");
 470
 471     } /*for( entryLoop )*/
 472
 473
 474 } /*AliITSDCSDataSDD::PrintValues()*/
 475
 476 //---------------------------------------------------------------------------
 477
 478 Int_t AliITSDCSDataSDD::FindIndex( Int_t timeStamp, const TArrayI &timeStampArray, Int_t n ) const
 479 {
 480 // Provides binary search in the time array. Returns index in the array of time
 481 //  stamps by selected value. Returns -1 if the time is less than time stamp in
 482 //  the timeArray[0]
 483
 484   if( n < 1 ) return -1;// Empty array or wrong value of array size
 485
 486   if( timeStamp >= timeStampArray.At(n-1) ) return n-1;
 487                         // Time is larger than last timestamp - last value in the array have
 488                         //  to be used. This is the most frequent case, so it have sense
 489                         //  to check it and avoid searching.
 490
 491   if( timeStamp < timeStampArray.At(0) ) return -1;
 492                         // Time is less than all time stamp stored in the array
 493
 494   Int_t left = 0;
 495   Int_t right = n-1;
 496   Int_t middle = (left + right)/2;
 497
 498   while( !( middle == left || middle == right) )
 499   {                     // Binary search in the time stamp array
 500
 501      if( timeStampArray.At(middle) < timeStamp )
 502       left = middle;
 503      else
 504       right = middle;
 505      middle = (left + right)/2;
 506   } /*while*/
 507
 508   if( timeStamp >= timeStampArray.At(right) )
 509    return right;
 510   else
 511    return left;
 512
 513 } /*AliITSDCSDataSDD::FindIndexByTimeStamp*/
 514
 515 //---------------------------------------------------------------------------