ITS/CreateSDDDCSMap.C

   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
  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
  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
  23 Int_t sizeOfMapContent = 0;
  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
  50  printf( "DCSAliasMap created, it size is %i byte ...\n", sizeOfMapContent );
  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
  67  Int_t freqROTL = 300;  // Frequency of fixed readout
  68  Float_t fluctROTL = 5.0;
  69                         // Allowed fluctuation (%)
  70
  71 // Temperature readout status (left side) - behavior of SDD chip
  72
  73   Int_t freqROStTL = 300;// Frequency of fixed readout
  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
  85  Int_t freqROTR = 300;   // Frequency of fixed readout
  86  Float_t fluctROTR = 5.0;
  87                         // Allowed fluctuation (%)
  88
  89 // Temperature readout status (right side) - behavior of SDD
  90
  91   Int_t freqROStTR = 300;// Frequency of fixed readout
  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
 100  Float_t fluctHV = 0.03;// Fluctuation (gaussian sigma)
 101
 102 // --- High voltage readout - behavior of DCS -------------------
 103
 104  Int_t freqROHV = 300;   // Frequency of fixed readout
 105  Float_t fluctROHV = 0.01;
 106                         // Allowed fluctuation (%)
 107
 108 // --- High voltage readout status - behavior of SDD voltage ----
 109
 110   Int_t freqROOK = 300;  // Frequency of fixed readout
 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
 118  Float_t fluctMV = 0.005;
 119                         // Fluctuation (gaussian sigma)
 120
 121 // --- Medium voltage readout - behavior of DCS -----------------
 122
 123  Int_t freqROMV = 300;   // Frequency of fixed readout
 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
 160   sizeOfMapContent += sizeof( TMap );
 161
 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
 212             sizeOfMapContent += 7 * sizeof( TObjArray );
 213
 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
 245             Int_t endingTimeStamp = /*1197477000;*/ stopTime.GetSec();
 246
 247             for( Int_t timeLoop = /*1197470000 */ startTime.GetSec(); timeLoop < endingTimeStamp; timeLoop ++ )
 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
 356   sizeOfMapContent += (created + created1 ) * ( sizeof( AliDCSValue ) + sizeof( AliDCSValue * ) );
 357
 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
 379   sizeOfMapContent += sizeof( TMap );
 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
 406             sizeOfMapContent += 7 * sizeof( TObjArray );
 407
 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;
 422             nrOfRecords = (Int_t)(maxRecords * ( gRandom->Rndm() ) );
 423             timeStamp = 1000000000;
 424             for( Int_t recLoop = 0; recLoop < nrOfRecords; recLoop ++ )
 425             {
 426                if( randomTimeStamps )
 427                 timeStamp = (Int_t)(1200000000*(gRandom->Rndm()));
 428                else
 429                 timeStamp += (Int_t)(50*(gRandom->Rndm()) );
 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);
 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
 448                 timeStamp += (Int_t)(50*(gRandom->Rndm()) );
 449                dcsVal = new AliDCSValue( (Float_t)( 1600 + 200*(gRandom->Rndm()) ), timeStamp );
 450                valueSetH->Add(dcsVal);
 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;
 457             nrOfRecords = (Int_t)(maxRecords * ( gRandom->Rndm() ));
 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
 464                 timeStamp += (Int_t)(50*(gRandom->Rndm()) );
 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;
 473             nrOfRecords = (Int_t)(maxRecords * ( gRandom->Rndm() ));
 474             timeStamp = 1000000000;
 475             for( Int_t recLoop = 0; recLoop < nrOfRecords; recLoop ++ )
 476             {
 477                if( randomTimeStamps )
 478                 timeStamp = (Int_t)(1200000000*(gRandom->Rndm()));
 479                 else
 480                   timeStamp += (Int_t)(50*(gRandom->Rndm()) );
 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;
 489             nrOfRecords = (Int_t)(maxRecords * ( gRandom->Rndm() ));
 490             timeStamp = 1000000000;
 491             for( Int_t recLoop = 0; recLoop < nrOfRecords; recLoop ++ )
 492             {
 493                if( randomTimeStamps )
 494                 timeStamp = (Int_t)(1200000000*(gRandom->Rndm()));
 495                else
 496                  timeStamp += (Int_t)(50*(gRandom->Rndm()) );
 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;
 505             nrOfRecords = (Int_t)(maxRecords * ( gRandom->Rndm() ));
 506             timeStamp = 1000000000;
 507             for( Int_t recLoop = 0; recLoop < nrOfRecords; recLoop ++ )
 508             {
 509                if( randomTimeStamps )
 510                  timeStamp = (Int_t)(1200000000*(gRandom->Rndm()));
 511                else
 512                  timeStamp += (Int_t)(50*(gRandom->Rndm()) );
 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;
 524             nrOfRecords = (Int_t)(maxRecords * ( gRandom->Rndm() ));
 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
 531                  timeStamp += (Int_t)(50*(gRandom->Rndm()) );
 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
 549   sizeOfMapContent += created * ( sizeof( AliDCSValue ) + sizeof( AliDCSValue * ) );
 550
 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;
 563
 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
 677            fprintf( outputFile, "|  time (s)     HV     |  time (s)      MV     |  time (s)     TL    |  time (s)     TR    | time (s)   StTL |" );
 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 )
 703                fprintf( outputFile, " %12i  %2.3f | ", ((AliDCSValue*)arrMV->At(entryLoop))->GetTimeStamp(),
 704                                                                    ((AliDCSValue*)arrMV->At(entryLoop))->GetFloat() );
 705                else
 706                fprintf( outputFile, "                      | ");
 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*/