New treatment of DCS data points for SDD (V. Pospisil)
authormasera <masera@f7af4fe6-9843-0410-8265-dc069ae4e863>
Wed, 13 Feb 2008 10:44:50 +0000 (10:44 +0000)
committermasera <masera@f7af4fe6-9843-0410-8265-dc069ae4e863>
Wed, 13 Feb 2008 10:44:50 +0000 (10:44 +0000)
ITS/AliITSDCSAnalyzerSDD.cxx
ITS/AliITSDCSAnalyzerSDD.h
ITS/AliITSDCSDataSDD.cxx
ITS/AliITSDCSDataSDD.h
ITS/CreateSDDDCSMap.C [new file with mode: 0644]

index 2f632d1..4e99e53 100644 (file)
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
 
-/* $Id$ */
+/* $Id:$ */
 
 ///////////////////////////////////////////////////////////////////
 //                                                               //
 // Implementation of the class for SDD DCS data analysis         //
 // Origin: F.Prino, Torino, prino@to.infn.it                     //
-//                                                               //
+//         V.Pospisil, CTU Prague, gdermog@seznam.cz             //
 ///////////////////////////////////////////////////////////////////
 
 
 #include "AliITSDCSAnalyzerSDD.h"
 #include "AliDCSValue.h"
-
-
-
-const Int_t AliITSDCSAnalyzerSDD::fgkNcathodes = 291;
-const Float_t AliITSDCSAnalyzerSDD::fgkCathodePitch = 0.0120;
-const Int_t AliITSDCSAnalyzerSDD::fgkTemperatureStatusOK = 4;
+#include "AliLog.h"
+#include "AliITSgeomTGeo.h"
 
 ClassImp(AliITSDCSAnalyzerSDD)
 
 //---------------------------------------------------------------
-AliITSDCSAnalyzerSDD::AliITSDCSAnalyzerSDD():
-TObject(),
-fDCSData(0)
-{
-  // Default constructor
+  AliITSDCSAnalyzerSDD::AliITSDCSAnalyzerSDD(): TObject(),
+fHVDelay(0),fMVDelay(0),fTLDelay(0),fTRDelay(0),fStTLDelay(0),fStTRDelay(0),fOKDelay(0)
+{                       
+// Default constructor
   Init();
-  fDCSData=new AliITSDCSDataSDD*[kNmodules];
-}
+} /*AliITSDCSAnalyzerSDD::AliITSDCSAnalyzerSDD*/
+
 //---------------------------------------------------------------
-AliITSDCSAnalyzerSDD::AliITSDCSAnalyzerSDD(const AliITSDCSAnalyzerSDD& /* dcsa */):
-TObject(),
-fDCSData(0)
-{
-  // copy constructor
-  // Copies are not allowed. The method is protected to avoid misuse.
-  AliError("Copy constructor not allowed");
-}
+
+AliITSDCSAnalyzerSDD::AliITSDCSAnalyzerSDD(const AliITSDCSAnalyzerSDD& /* dcsa */): TObject(),
+fHVDelay(0),fMVDelay(0),fTLDelay(0),fTRDelay(0),fStTLDelay(0),fStTRDelay(0),fOKDelay(0)
+{                       
+// copy constructor
+                        // Copies are not allowed. The method is protected to avoid misuse.
+  fprintf( stderr, "Copy constructor not allowed");
+} /*AliITSDCSAnalyzerSDD::AliITSDCSAnalyzerSDD*/
+
 //---------------------------------------------------------------
-AliITSDCSAnalyzerSDD& AliITSDCSAnalyzerSDD::operator=(const AliITSDCSAnalyzerSDD& /* dcsa */){
-  // assigment operator
-  // Assignment is not allowed. The method is protected to avoid misuse.
-  AliError("Assignment operator not allowed");
+
+AliITSDCSAnalyzerSDD& AliITSDCSAnalyzerSDD::operator=(const AliITSDCSAnalyzerSDD& /* dcsa */)
+{                       
+// assigment operator
+                        // Assignment is not allowed. The method is protected to avoid misuse.
+  fprintf( stderr, "Assignment operator not allowed");
   return *this;
-}
+}/*AliITSDCSAnalyzerSDD::operator=*/
+
 //---------------------------------------------------------------
-AliITSDCSAnalyzerSDD::~AliITSDCSAnalyzerSDD(){
-  // destructor
-  for(int j=0; j<kNmodules; j++){
+
+AliITSDCSAnalyzerSDD::~AliITSDCSAnalyzerSDD()
+{                       
+// destructor
+  for(int j=0; j<kNmodules; j++)
+  {
     if(fDCSData[j]) delete fDCSData[j];
-  }
-  delete [] fDCSData;
-}
+  } /*for( j )*/
+} /*AliITSDCSAnalyzerSDD::~AliITSDCSAnalyzerSDD*/
+
 //---------------------------------------------------------------
-void AliITSDCSAnalyzerSDD::AnalyzeData(TMap* dcsMap){
-  // Data processing
-   
-  for(int j=0; j<kNmodules; j++){
-    TObjArray* arrHV = (TObjArray*) dcsMap->GetValue(fHVDPNames[j].Data());   
-    if(!arrHV){
-      AliError(Form("DCS HV alias %s not found!", fHVDPNames[j].Data()));
-      continue;
-    }
-    TObjArray* arrMV = (TObjArray*) dcsMap->GetValue(fMVDPNames[j].Data());   
-    if(!arrMV){
-      AliError(Form("DCS MV alias %s not found!", fMVDPNames[j].Data()));
-      continue;
-    }
-    TObjArray* arrTL = (TObjArray*) dcsMap->GetValue(fTLDPNames[j].Data());   
-    if(!arrTL){
-      AliError(Form("DCS TEMP_L alias %s not found!", fTLDPNames[j].Data()));
-      continue;
-    }
-    TObjArray* arrTR = (TObjArray*) dcsMap->GetValue(fTRDPNames[j].Data());   
-    if(!arrTR){
-      AliError(Form("DCS TEMP_R alias %s not found!", fTRDPNames[j].Data()));
-      continue;
-    }
-    TObjArray* arrStTL = (TObjArray*) dcsMap->GetValue(fTLStDPNames[j].Data());   
-    if(!arrStTL){
-      AliError(Form("DCS TEMP_L_STATE alias %s not found!", fTLStDPNames[j].Data()));
-      continue;
-    }
-    TObjArray* arrStTR = (TObjArray*) dcsMap->GetValue(fTRStDPNames[j].Data());   
-    if(!arrStTR){
-      AliError(Form("DCS TEMP_R_STATE alias %s not found!", fTRStDPNames[j].Data()));
-      continue;
-    }
-
-    Int_t nData=arrHV->GetEntries();
-    fDCSData[j]=new AliITSDCSDataSDD(nData);
-    for(int i =0; i<arrHV->GetEntries(); i++) {
-      AliDCSValue* valHV = (AliDCSValue*) arrHV->At(i);
-      AliDCSValue* valMV = (AliDCSValue*) arrMV->At(i);
-      AliDCSValue* valTL = (AliDCSValue*) arrTL->At(i);
-      AliDCSValue* valTR = (AliDCSValue*) arrTR->At(i);
-      AliDCSValue* valStTL = (AliDCSValue*) arrStTL->At(i);
-      AliDCSValue* valStTR = (AliDCSValue*) arrStTR->At(i);
-      Int_t timeStamp = valHV->GetTimeStamp();
-      Float_t hv = valHV->GetFloat();
-      Float_t mv = valMV->GetFloat();
-      Float_t edrift = (hv-mv)/(Float_t)fgkNcathodes/fgkCathodePitch;
-      Int_t statusTL=valStTL->GetInt();
-      Int_t statusTR=valStTR->GetInt();
-      Float_t tleft = -9999.;
-      if(statusTL==fgkTemperatureStatusOK) tleft=valTL->GetFloat();
-      Float_t tright = -9999.;
-      if(statusTR==fgkTemperatureStatusOK) tright=valTR->GetFloat();
-      fDCSData[j]->SetValues(timeStamp,edrift,tleft,tright);
-    }
-  }
-}
+
+void AliITSDCSAnalyzerSDD::AnalyzeData(TMap* dcsMap)
+{                       
+// Data processing
+
+   Int_t counter = 0;
+
+   for( Int_t iLay = 3; iLay < 5; iLay++ )
+   {
+
+      Int_t maxLad = ( iLay == 3) ? kNladders3 : kNladders4;
+      Int_t maxMod = ( iLay == 3) ? kNmodLad3 : kNmodLad4;
+
+      for(Int_t iLad = 0; iLad < maxLad; iLad++)
+      {
+         for(Int_t iMod = 0; iMod < maxMod; iMod++)
+         {
+                        // Loads arrays of DCS variables from map. Variables are 
+                        //  searched by names (for ex. SDD_LAYER3_LADDER5_MODULE4_HV)
+
+            Int_t moduleLoop = AliITSgeomTGeo::GetModuleIndex( iLay, iLad + 1, iMod + 1 ) - 240;
+
+            TObjArray* arrHV = (TObjArray*) dcsMap->GetValue( fHVDPNames[moduleLoop].Data() );
+            if(!arrHV)
+            {
+               fprintf( stderr, Form("DCS HV alias %s not found!\n", fHVDPNames[moduleLoop].Data()));
+               continue;
+            } /*if*/
+
+            TObjArray* arrMV = (TObjArray*) dcsMap->GetValue( fMVDPNames[moduleLoop].Data() );
+            if(!arrMV)
+            {
+               fprintf( stderr, Form("DCS MV alias %s not found!\n", fMVDPNames[moduleLoop].Data()));
+               continue;
+            } /*if*/
+
+            TObjArray* arrOK = (TObjArray*) dcsMap->GetValue( fOKDPNames[moduleLoop].Data() );
+            if(!arrOK)
+            {
+               fprintf( stderr, Form("DCS MOD_OK alias %s not found!\n", fOKDPNames[moduleLoop].Data()));
+               continue;
+            } /*if*/
+
+            TObjArray* arrTL = (TObjArray*) dcsMap->GetValue( fTLDPNames[moduleLoop].Data() );
+            if(!arrTL)
+            {
+               fprintf( stderr, Form("DCS TEMP_L alias %s not found!\n", fTLDPNames[moduleLoop].Data()));
+               continue;
+            } /*if*/
+
+            TObjArray* arrTR = (TObjArray*) dcsMap->GetValue( fTRDPNames[moduleLoop].Data() );
+            if(!arrTR)
+            {
+               fprintf( stderr, Form("DCS TEMP_R alias %s not found!\n", fTRDPNames[moduleLoop].Data()));
+               continue;
+            } /*if*/
+
+            TObjArray* arrStTL = (TObjArray*) dcsMap->GetValue( fTLStDPNames[moduleLoop].Data() );
+            if(!arrStTL)
+            {
+               fprintf( stderr, Form("DCS TEMP_L_STATE alias %s not found!\n", fTLStDPNames[moduleLoop].Data()));
+               continue;
+            } /*if*/
+
+            TObjArray* arrStTR = (TObjArray*) dcsMap->GetValue( fTRStDPNames[moduleLoop].Data() );
+            if(!arrStTR) 
+            {
+               fprintf( stderr, Form("DCS TEMP_R_STATE alias %s not found!\n", fTRStDPNames[moduleLoop].Data()));
+               continue;
+            } /*if*/
+
+            fDCSData[moduleLoop] = new AliITSDCSDataSDD;
+                        // DCS data for specific SDD module will be stored in this class
+
+            Int_t nEntries;     
+                        // Number of entries in each TObjArray, that contains DCS variable values
+            AliDCSValue *valToProcess;
+                        // Pointer to currently processed DCS variable value
+
+            nEntries = arrTL->GetEntries();
+            fDCSData[moduleLoop]->SetNPointsTempLeft( nEntries );
+                        // Left temperature array size is set
+
+            for( Int_t tlLoop = 0; tlLoop < nEntries; tlLoop++ )
+            {           // Left temerature values are copied into the AliITSDCSDataSDD TempLeft array
+               valToProcess = (AliDCSValue *)(arrTL->At(tlLoop));
+               fDCSData[moduleLoop]->SetValueTempLeft( valToProcess->GetTimeStamp() - fTLDelay, valToProcess->GetFloat() );
+            } /*for( tlLoop )*/
+            counter += nEntries;
+
+            nEntries = arrTR->GetEntries();
+            fDCSData[moduleLoop]->SetNPointsTempRight( nEntries );
+                        // Right temperature array size is set 
+
+            for( Int_t trLoop = 0; trLoop < nEntries; trLoop++ )
+            {           // Right temerature values are copied into the AliITSDCSDataSDD TempRight array
+               valToProcess = (AliDCSValue *)(arrTR->At(trLoop));
+               fDCSData[moduleLoop]->SetValueTempRight( valToProcess->GetTimeStamp() - fTRDelay, valToProcess->GetFloat() );
+            } /*for( trLoop )*/
+            counter += nEntries;
+
+            nEntries = arrHV->GetEntries();
+            fDCSData[moduleLoop]->SetNPointsHV( nEntries );
+                        // HV array size is set 
+
+            for( Int_t hvLoop = 0; hvLoop < nEntries; hvLoop++ )
+            {           // HV values are copied into the AliITSDCSDataSDD HV array
+               valToProcess = (AliDCSValue *)(arrHV->At(hvLoop));
+               fDCSData[moduleLoop]->SetValueHV( valToProcess->GetTimeStamp() - fHVDelay, valToProcess->GetFloat() );
+            } /*for( hvLoop )*/
+            counter += nEntries;
+
+            nEntries = arrMV->GetEntries();
+            fDCSData[moduleLoop]->SetNPointsMV( nEntries );
+                        // MV array size is set 
+
+            for( Int_t mvLoop = 0; mvLoop < nEntries; mvLoop++ )
+            {           // MV values are copied into the AliITSDCSDataSDD MV array
+               valToProcess = (AliDCSValue *)(arrMV->At(mvLoop));
+               fDCSData[moduleLoop]->SetValueMV( valToProcess->GetTimeStamp() - fMVDelay, valToProcess->GetFloat() );
+            } /*for( mvLoop )*/
+            counter += nEntries;
+
+/* Following part of the code is responsibile for the condensing of all status information given by DCS
+   into one array of Char_t. Each record of this array is in principle a bit map : 
+
+      0. bit ... _OK
+      1. bit ... _TEMP_L_STATE
+      2. bit ... _TEMP_R_STATE 
+
+   Each record have its own time stamp. Because there are three inputs with independent time stamp,
+   some algorithm which assigns new time stamp to bitmap according to three input time stamps is
+   necessary.
+
+   Let's vizualize time stamps of the three input arrays. There is time on x-axis :
+
+            +------------+---------------------+------
+            |            |                     |           _OK
+      +------+------+---+--------+------------+------
+      |      |      |            |            |           _TEMP_L_STATE
+   +--+------+---+--+-------+-----+--------+---+------
+   |             |          |     |        |   |          _TEMP_R_STATE
+   +-------------+----------+-----+--------+---+------
+
+   |   |    | |  |   |   |  |     |        |   |
+   V   V    V V  V   V   V  V     V        V   V
+
+   +---+----+-+--+---+---+--+-----+--------+---+------
+   |   |    | |  |   |   |  |     |        |   |           Status bitmap
+   +---+----+-+--+---+---+--+-----+--------+---+------
+
+
+   Principle of combining three status records into one is visible from the picture.
+   If there are two sequent records with the same status bitmap, they are joined into
+   one (with the time stamp of the earliest one).
+
+*/
+
+            Int_t nStTLEntries = arrStTL->GetEntries();
+            Int_t nStTREntries = arrStTR->GetEntries();
+            Int_t nOKEntries = arrOK->GetEntries();
+                        // Gets number of _STAT_L, _STAT_R and _OK values stored in dcsMap
+
+            if( nStTLEntries < 1 )
+            {           // TObjArray arrStTL is empty. This would cause segmentation violation during
+                        //  the condensing, so this case must be handled before algorithm starts
+               fprintf( stderr, "%s contains no data!\n", fTLStDPNames[moduleLoop].Data() );
+               nStTLEntries = 1;
+               arrStTL->Add( new AliDCSValue(  (Int_t)0, 0x7FFFFFFF ) );
+                        // 0x7FFFFFFF = 2147483647, maximal signed Int_t number. Left temperature
+                        //  sensor will be regarded as switched-off during whole run.
+            } /*if*/
+            if( nStTREntries < 1 )
+            {           // TObjArray arrStTR is empty. This would cause segmentation violation during
+                        //  the condensing, so this case must be handled before algorithm starts
+               fprintf( stderr, "%s contains no data!\n", fTRStDPNames[moduleLoop].Data() );
+               nStTREntries = 1;
+               arrStTR->Add( new AliDCSValue(  (Int_t)0, 0x7FFFFFFF ) );
+                        // 0x7FFFFFFF = 2147483647, maximal signed Int_t number. Right temperature
+                        //  sensor will be regarded as switched-off during whole run.
+            } /*if*/
+
+            if( nOKEntries < 1 )
+            {           // TObjArray arrOK is empty. This would cause segmentation violation during
+                        //  the condensing, so this case must be handled before algorithm starts
+               fprintf( stderr, "%s contains no data!\n", fOKDPNames[moduleLoop].Data() );
+               nOKEntries = 1;
+               arrOK->Add( new AliDCSValue(  (Bool_t)0, 0x7FFFFFFF ) );
+                        // 0x7FFFFFFF = 2147483647, maximal signed Int_t number.
+                        //  Module will be regarded as switched-off during whole run.
+            } /*if*/
+
+            arrStTL->Sort();
+            arrStTR->Sort();
+            arrOK->Sort();
+                        // Condensing would work properly only in the case that
+                        //  the input arrays are sorted by time
+
+            Int_t nEntriesMax = nStTLEntries + nStTREntries + nOKEntries;
+            fDCSData[moduleLoop]->SetNPointsStatus( nEntriesMax );
+                        // Determines necessary length of new array and sets its size 
+                        //  Lot of space in such defined array will be probably 
+                        //  vacant after the analysis, but this will be corrected
+                        //  by Compress() method
+
+            Int_t idxStTL = 0;
+            Int_t idxStTR = 0;
+            Int_t idxOK = 0;    
+                        // Input arrays indexes
+
+            Int_t tsStTL, tsStTR, tsOK;
+                        // Time stamps ofinput arrays
+            Int_t tsNew;// New time stamp (output array)
+
+            Char_t bitStatus;   
+                        // New status record :
+                        // 0. bit ... _OK
+                        // 1. bit ... _TEMP_L_STATE
+                        // 2. bit ... _TEMP_R_STATE 
+            Char_t lastBitStatus = 100;
+
+            AliDCSValue *valStTL, *valStTR, *valOK;
+                        // Pointers to input arrays records (input arrays are TObjArrays
+                        //  containing objects of type AliDCSValue
+
+            tsStTR = ( (AliDCSValue *)arrStTR->At(0) )->GetTimeStamp() - fStTLDelay;
+            tsStTL = ( (AliDCSValue *)arrStTL->At(0) )->GetTimeStamp() - fStTRDelay;
+            tsOK = ( (AliDCSValue *)arrOK->At(0) )->GetTimeStamp() - fOKDelay;
+                        // Time stamps of first records in input filea are readed (and delays are substracted)
+
+            tsNew = (tsStTR < tsStTL) ? tsStTR : tsStTL;
+            if( tsNew > tsOK ) tsNew = tsOK;
+                        // Time intervals are "prolonged" to the very eaarliest of time stamps.
+                        //  It means that first output time stamp will be the same as the one
+                        //  which is first in input arrays. Values of other DCS variables are
+                        //  not defined in this time yet, but they will be treated as equal to
+                        //  values in first records of input arrays.
+
+            nStTLEntries--; nStTREntries--; nOKEntries--;
+                        // Indexes in the input array must not exceed last records.
+
+            while( (idxStTL < nStTLEntries) || (idxStTR < nStTREntries) || (idxOK < nOKEntries) )
+            {           // Loop goes throug all three input files
+
+               valStTL = (AliDCSValue *)( arrStTL->At(idxStTL) );
+               valStTR = (AliDCSValue *)( arrStTR->At(idxStTR) );
+               valOK = (AliDCSValue *)( arrOK->At(idxOK) );
+                        // Values are readed from input arrays
+
+               bitStatus = 0;
+               if( valOK->GetBool() ) bitStatus += 1;        // 0. bit - _OK
+               if( valStTL->GetInt() == 1 ) bitStatus += 2;  // 1. bit - _TEMP_L_STATE
+               if( valStTR->GetInt() == 1 ) bitStatus += 4;  // 2. bit - _TEMP_R_STATE
+                        // Bit map is created
+
+               if( lastBitStatus != bitStatus )
+               {              // If the status bitmap is teh same as last one, it would not be stored.
+                              //  It will save much space.
+                  fDCSData[moduleLoop]->SetValueStatus( tsNew, bitStatus );
+                              // Bit map is written into the output array (if different from last value )
+                  lastBitStatus = bitStatus;
+                  counter += nEntries;
+               } /*if*/
+
+               if( idxStTL == nStTLEntries )
+                tsStTL = 0x7FFFFFFF;  // = 2147483647, maximal signed Int_t number
+               else
+                tsStTL = ( (AliDCSValue *)arrStTL->At(idxStTL + 1) )->GetTimeStamp() - fStTLDelay;
+
+               if( idxStTR == nStTREntries )
+                tsStTR = 0x7FFFFFFF;  // = 2147483647, maximal signed Int_t number
+               else
+                tsStTR = ( (AliDCSValue *)arrStTR->At(idxStTR + 1) )->GetTimeStamp() - fStTRDelay;
+
+               if( idxOK == nOKEntries )
+                tsOK = 0x7FFFFFFF;    // = 2147483647, maximal signed Int_t number
+               else
+                tsOK = ( (AliDCSValue *)arrOK->At(idxOK + 1) )->GetTimeStamp() - fOKDelay;
+                        // Reads time stamps of folowing records in the input arrays (and substracts delays).
+                        // Validity of the last records in the input arrays are prolonged
+                        //  to "infinity"
+
+               if( tsStTL == tsOK && tsStTR == tsOK )  { tsNew = tsStTL; idxStTL++; idxStTR++; idxOK++; continue; }
+               if( tsStTL == tsStTR && tsStTR < tsOK ) { tsNew = tsStTL; idxStTL++; idxStTR++; continue; }
+               if( tsStTL == tsOK && tsOK < tsStTR )   { tsNew = tsStTL; idxStTL++; idxOK++; continue; }
+               if( tsStTR == tsOK && tsOK < tsStTL )   { tsNew = tsStTR; idxStTR++; idxOK++; continue; } 
+               if( tsOK < tsStTL && tsOK < tsStTR )    { tsNew = tsOK;   idxOK++;   continue; }
+               if( tsStTL < tsOK && tsStTL < tsStTR )  { tsNew = tsStTL; idxStTL++; continue; }
+               /*Last possibile case*/                 { tsNew = tsStTR; idxStTR++; }
+
+                        // Index of array, whose following record have time stamp closest to just written one,
+                        //  is increased. If there are more records with identical time stamps meeting this condition,
+                        //  all correspondent indexes are increased. 
+
+            } /*while*/
+
+
+          } /*for( iMod )*/
+       } /*for( iLad )*/
+    } /*for( iLay )*/
+
+
+} /*AliITSDCSAnalyzerSDD::AnalyzeData*/
+
 
 //---------------------------------------------------------------
-void AliITSDCSAnalyzerSDD::Init(){
+
+
+void AliITSDCSAnalyzerSDD::Init()
+{
   // Initialization of DCS DP names
   Char_t dpName[50];
   Char_t modName[50];
-  for(Int_t iLad=0; iLad<kNladders3; iLad++){
-    for(Int_t iMod=0; iMod<kNmodLad3;iMod++){
-      sprintf(modName,"SDD_LAYER3_LADDER%02d_MODULE%d",iLad,iMod);
-      Int_t id=iMod+iLad*kNmodLad3;
-      sprintf(dpName,"%s_HV",modName);
-      fHVDPNames[id]=dpName;
-      sprintf(dpName,"%s_MV",modName);
-      fMVDPNames[id]=dpName;
-      sprintf(dpName,"%s_TEMP_L",modName);
-      fTLDPNames[id]=dpName;
-      sprintf(dpName,"%s_TEMP_R",modName);
-      fTRDPNames[id]=dpName;
-      sprintf(dpName,"%s_TEMP_L_STATE",modName);
-      fTLStDPNames[id]=dpName;
-      sprintf(dpName,"%s_TEMP_R_STATE",modName);
-      fTRStDPNames[id]=dpName;
-    }
-  }
-  for(Int_t iLad=0; iLad<kNladders4; iLad++){
-    for(Int_t iMod=0; iMod<kNmodLad4;iMod++){
-      sprintf(modName,"SDD_LAYER4_LADDER%02d_MODULE%d",iLad,iMod);
-      Int_t id=kNladders3*kNmodLad3+iMod+iLad*kNmodLad4;
-      sprintf(dpName,"%s_HV",modName);
-      fHVDPNames[id]=dpName;
-      sprintf(dpName,"%s_MV",modName);
-      fMVDPNames[id]=dpName;
-      sprintf(dpName,"%s_TEMP_L",modName);
-      fTLDPNames[id]=dpName;
-      sprintf(dpName,"%s_TEMP_R",modName);
-      fTRDPNames[id]=dpName;
-      sprintf(dpName,"%s_TEMP_L_STATE",modName);
-      fTLStDPNames[id]=dpName;
-      sprintf(dpName,"%s_TEMP_R_STATE",modName);
-      fTRStDPNames[id]=dpName;
-    }
-  } 
-}
+
+
+  for( Int_t iLay = 3; iLay < 5; iLay++ )
+  {
+
+     Int_t maxLad = ( iLay == 3) ? kNladders3 : kNladders4;
+     Int_t maxMod = ( iLay == 3) ? kNmodLad3 : kNmodLad4;
+
+     for(Int_t iLad=0; iLad<maxLad; iLad++)
+     {
+        for(Int_t iMod=0; iMod<maxMod;iMod++)
+        {
+           sprintf(modName,"SDD_LAYER%i_LADDER%02d_MODULE%d", iLay, iLad, iMod);
+           Int_t id = AliITSgeomTGeo::GetModuleIndex( iLay, iLad + 1, iMod + 1 ) - 240;
+
+           sprintf(dpName,"%s_HV",modName);
+           fHVDPNames[id]=dpName;
+           sprintf(dpName,"%s_MV",modName);
+           fMVDPNames[id]=dpName;
+           sprintf(dpName,"%s_OK",modName);
+           fOKDPNames[id]=dpName;
+           sprintf(dpName,"%s_TEMP_L",modName);
+           fTLDPNames[id]=dpName;
+           sprintf(dpName,"%s_TEMP_R",modName);
+           fTRDPNames[id]=dpName;
+           sprintf(dpName,"%s_TEMP_L_STATE",modName);
+           fTLStDPNames[id]=dpName;
+           sprintf(dpName,"%s_TEMP_R_STATE",modName);
+           fTRStDPNames[id]=dpName;
+
+        } /*for( iMod )*/
+     } /*for( iLad )*/
+
+  } /*for( iLay )*/
+
+
+} /*AliITSDCSAnalyzerSDD::Init*/
 
 //---------------------------------------------------------------
-void AliITSDCSAnalyzerSDD::PrintDCSDPNames(){
+void AliITSDCSAnalyzerSDD::PrintDCSDPNames( FILE *output )
+{
   // Data processing
-  for(int j=0; j<kNmodules; j++){
-    printf("Module %d      %s   %s   %s   %s\n",j,fHVDPNames[j].Data(),fMVDPNames[j].Data(),fTLDPNames[j].Data(),fTRDPNames[j].Data());
-  }
-}
+  for( Int_t j = 0; j < kNmodules; j++ )
+  {
+    fprintf( output, "Module %d      %s   %s   %s   %s\n",j,fHVDPNames[j].Data(),
+                          fMVDPNames[j].Data(),fTLDPNames[j].Data(),fTRDPNames[j].Data());
+  } /*for( j )*/
+} /*AliITSDCSAnalyzerSDD::PrintDCSDPNames*/
index f1663cc..13efef8 100644 (file)
@@ -7,58 +7,81 @@
 /* $Id$ */
 
 ///////////////////////////////////////////////////////////////////
-//                                                               //
 // Class for SDD dcs data analysis                               //
 //  called by AliITSPreprocessorSDD                              //
 // Origin: F.Prino, Torino, prino@to.infn.it                     //
-//                                                               //
+//         V.Pospisil, CTU Prague, gdermog@seznam.cz             //
 ///////////////////////////////////////////////////////////////////
 
-
-
 #include <TMap.h>
+#include <TObjArray.h>
 #include "AliITSDCSDataSDD.h"
-#include "AliLog.h"
+#include "AliITSgeomTGeo.h"
 
-class AliITSDCSAnalyzerSDD : public TObject { 
+class AliITSDCSAnalyzerSDD : public TObject 
+{
 
  public:
   AliITSDCSAnalyzerSDD();
   ~AliITSDCSAnalyzerSDD();
 
 
-  void AnalyzeData(TMap* dcsMap);
-  void PrintDCSDPNames();
-  AliITSDCSDataSDD* GetDCSData(Int_t iModule) const {return fDCSData[iModule];}
+  void SetVoltageDelays( Int_t HVDelay, Int_t MVDelay )     { fHVDelay = HVDelay; fMVDelay = MVDelay; }
+  void SetTemperatureDelays( Int_t TLDelay, Int_t TRDelay ) { fTLDelay = TLDelay; fTRDelay = TRDelay; }
+  void SetStatusDelays( Int_t StTLDelay, Int_t StTRDelay, Int_t OKDelay ) 
+                                                            { fStTLDelay = StTLDelay; fStTRDelay = StTRDelay; fOKDelay = OKDelay; }
+                        // There is some delay between variable readout and setting up the time stamp. Delays differs
+                        //  in voltage and temperature readouts. So it is necessary to substract some value from time stamps
+                        //  during the data processing 
+
+  void AnalyzeData( TMap* dcsMap );
+                        // Processes the data
+
+  void PrintDCSDPNames( FILE *output = stdout );
+                        // Prints module identifications in text mode
+
+  AliITSDCSDataSDD* GetDCSData( Int_t iModule ) const { return fDCSData[iModule]; }
+                        // Returns data for module specified by its index in range 0..259
+
+  AliITSDCSDataSDD* GetDCSData( Int_t iLayer, Int_t iLadder, Int_t iModule ) const
+                                  { return fDCSData[AliITSgeomTGeo::GetModuleIndex( iLayer, iLadder, iModule ) - 240]; }
+                        // Returns data for module specified by layer[3..4], ladder[1..22] and module number[1..8]
 
  protected:
-  // Copy constructor and assignment operator not allowed.
-  // They are protected to avoid misuse
   AliITSDCSAnalyzerSDD(const AliITSDCSAnalyzerSDD& /* dcsa  */);
   AliITSDCSAnalyzerSDD& operator=(const AliITSDCSAnalyzerSDD& /* dcsa */);
-  void Init();
+                        // Copy constructor and assignment operator not allowed.
+                        // They are protected to avoid misuse
 
- private:
+  void Init();          // Creates module text identifications
 
-  enum {kNmodules=260, 
-       kNladders3=14, 
-       kNladders4=22, 
-       kNmodLad3=6, 
-       kNmodLad4=8};
+ private:
 
-  static const Int_t fgkNcathodes; // number of SDD cathodes
-  static const Float_t fgkCathodePitch; // cathode pitch cm
-  static const Int_t fgkTemperatureStatusOK; // max. Drift Field variations
+  enum { kNmodules=260,
+         kNladders3=14,
+         kNladders4=22,
+         kNmodLad3=6,
+         kNmodLad4=8 };            // Basic SDD geometry
 
   TString fHVDPNames[kNmodules];   // DCS DP names for High Voltage  
   TString fMVDPNames[kNmodules];   // DCS DP names for Medium Voltage
+  TString fOKDPNames[kNmodules];   // DCS DP names for Medium Voltage
   TString fTLDPNames[kNmodules];   // DCS DP names for Temperature Left
   TString fTRDPNames[kNmodules];   // DCS DP names for Temperature Right
-  TString fTLStDPNames[kNmodules];   // DCS DP names for status of Temperature Left
-  TString fTRStDPNames[kNmodules];   // DCS DP names for status of Temperature Right
-  AliITSDCSDataSDD **fDCSData;  // values of DCS data points
+  TString fTLStDPNames[kNmodules]; // DCS DP names for status of Temperature Left
+  TString fTRStDPNames[kNmodules]; // DCS DP names for status of Temperature Right
+  AliITSDCSDataSDD *fDCSData[kNmodules];  // values of DCS data points
+
+  Int_t fHVDelay;     // There is some delay between variable readout
+  Int_t fMVDelay;     // and setting up the time stamp. Delays differs
+  Int_t fTLDelay;     // in voltage and temperature readouts. So it is
+  Int_t fTRDelay;     // necessary to substract some value from time stamp
+  Int_t fStTLDelay;   // during the data processing. 
+  Int_t fStTRDelay;   // Here are the values of delays stored
+  Int_t fOKDelay;     // for the 7 variables.
+
+  ClassDef(AliITSDCSAnalyzerSDD, 2);
 
-  ClassDef(AliITSDCSAnalyzerSDD, 1);
-};
+}; /*class AliITSDCSAnalyzerSDD*/
 
 #endif
index e6b4a7b..09538bb 100644 (file)
 //                                                               //
 // Implementation of the class containing SDD DCS data           //
 // Origin: F.Prino, Torino, prino@to.infn.it                     //
-//                                                               //
+//         V. Pospisil, CTU Praguem gdermog@seznam.cz            //
 ///////////////////////////////////////////////////////////////////
 
 #include "AliITSDCSDataSDD.h"
 #include "AliLog.h"
 
+#define AUTORESIZE 50
+
 ClassImp(AliITSDCSDataSDD)
 
-//---------------------------------------------------------------
-AliITSDCSDataSDD::AliITSDCSDataSDD():
-TObject(),
-fNpts(0),
-fSetPoints(0),
-fTimeStamp(),
-fDriftField(),
-fTemperatureLeft(),
-fTemperatureRight()
+//---------------------------------------------------------------------------
+AliITSDCSDataSDD::AliITSDCSDataSDD(): TObject(),
+fTempLeft(0),
+fTempLeftTimeStamp(0),
+fTempLeftMaxPoints(0),
+fTempLeftSetPoints(0),
+fTempRight(0),
+fTempRightTimeStamp(0),
+fTempRightMaxPoints(0),
+fTempRightSetPoints(0),
+fHV(0),
+fHVTimeStamp(0),
+fHVMaxPoints(0),
+fHVSetPoints(0),
+fMV(0),
+fMVTimeStamp(0),
+fMVMaxPoints(0),
+fMVSetPoints(0),
+fStatus(0),
+fStatusTimeStamp(0),
+fStatusMaxPoints(0),
+fStatusSetPoints(0)
 {
-  // default constructor
-}
-//---------------------------------------------------------------
-AliITSDCSDataSDD::AliITSDCSDataSDD(Int_t npts):
-TObject(),
-fNpts(npts),
-fSetPoints(0),
-fTimeStamp(npts),
-fDriftField(npts),
-fTemperatureLeft(npts),
-fTemperatureRight(npts)
+// default constructor
+} /*AliITSDCSDataSDD::AliITSDCSDataSDD*/
+
+//---------------------------------------------------------------------------
+
+void AliITSDCSDataSDD::SetNPointsTempLeft( Int_t npts )
 {
-  // standard constructor
-}
-//---------------------------------------------------------------
-void AliITSDCSDataSDD::SetNPoints(Int_t npts){
-  // Redimension and resets arrays
-  fNpts=npts;
-  fTimeStamp.Set(npts);
-  fDriftField.Set(npts);
-  fTemperatureLeft.Set(npts);
-  fTemperatureRight.Set(npts);
-}
-
-//---------------------------------------------------------------
-void AliITSDCSDataSDD::SetValues(Int_t time, Float_t field, Float_t templ, Float_t tempr){
-  // Set values of next array elements
-  if(fSetPoints>=fNpts){
-    AliWarning("Try to write outside array range");
+  //
+  if( npts < fTempLeftSetPoints)
+  {                     // Cannot resize arrays - some elements would be lost
+    AliWarning("Attemp to reduce size of full array (SDD DCS _TEMP_L)"); 
     return;
-  }
-  fTimeStamp.AddAt(time,fSetPoints);
-  fDriftField.AddAt(field,fSetPoints);
-  fTemperatureLeft.AddAt(templ,fSetPoints);
-  fTemperatureRight.AddAt(tempr,fSetPoints);
-  fSetPoints++;
-}
-//---------------------------------------------------------------
-void AliITSDCSDataSDD::Compress(){
-  // Redimension arrays removing the empty elements at the end
-  SetNPoints(fSetPoints);
-}
-//---------------------------------------------------------------
-void AliITSDCSDataSDD::PrintValues() const {
-  // Printout array contents
-  for(Int_t i=0;i<fNpts;i++){
-    printf("TimeStamp=%d   Drift Field=%f  Temperatures: Left Hybr=%f  Right Hybr=%f\n",fTimeStamp.At(i),fDriftField.At(i),fTemperatureLeft.At(i),fTemperatureRight.At(i));
-  }
-}
+  } /*if*/
+
+  fTempLeft.Set( npts );
+  fTempLeftTimeStamp.Set( npts );
+                        // Both temperature and tme stamp arrays are resized
+
+  fTempLeftMaxPoints = npts;
+                        // New size is stored
+} /*AliITSDCSDataSDD::SetNPointsTempLeft*/
+
+//---------------------------------------------------------------------------
+
+void AliITSDCSDataSDD::SetNPointsTempRight( Int_t npts )
+{
+  //
+  if( npts < fTempRightSetPoints)
+  {                     // Cannot resize arrays - some elements would be lost
+    AliWarning("Attemp to reduce size of full array (SDD DCS _TEMP_R)");
+    return;
+  } /*if*/
+
+  fTempRight.Set( npts );
+  fTempRightTimeStamp.Set( npts );
+                        // Both temperature and tme stamp arrays are resized
+
+  fTempRightMaxPoints = npts;
+                        // New size is stored
+} /*AliITSDCSDataSDD::SetNPointsTempRight*/
+
+//---------------------------------------------------------------------------
+
+void AliITSDCSDataSDD::SetNPointsHV( Int_t npts )
+{
+  //
+  if( npts < fHVSetPoints)
+  {                     // Cannot resize arrays - some elements would be lost
+    AliWarning("Attemp to reduce size of full array (SDD DCS _HV)");
+    return;
+  } /*if*/
+
+  fHV.Set( npts );
+  fHVTimeStamp.Set( npts );
+                        // Both temperature and tme stamp arrays are resized
+
+  fHVMaxPoints = npts;  // New size is stored
+
+}/*AliITSDCSDataSDD::SetNPointsHV*/
+
+//---------------------------------------------------------------------------
+
+void AliITSDCSDataSDD::SetNPointsMV( Int_t npts )
+{
+  //
+  if( npts < fMVSetPoints)
+  {                     // Cannot resize arrays - some elements would be lost
+    AliWarning("Attemp to reduce size of full array (SDD DCS _MV)");
+    return;
+  } /*if*/
+
+  fMV.Set( npts );
+  fMVTimeStamp.Set( npts );
+                        // Both temperature and tme stamp arrays are resized
+
+  fMVMaxPoints = npts;  // New size is stored 
+
+} /*AliITSDCSDataSDD::SetNPointsMV*/
+
+//---------------------------------------------------------------------------
+
+void AliITSDCSDataSDD::SetNPointsStatus( Int_t npts )
+{
+  //
+  if( npts < fStatusSetPoints)
+  {                     // Cannot resize arrays - some elements would be lost
+    AliWarning("Attemp to reduce size of full array (SDD DCS Status)");
+    return;
+  } /*if*/
+
+  fStatus.Set( npts );
+  fStatusTimeStamp.Set( npts );
+                        // Both temperature and tme stamp arrays are resized
+
+  fStatusMaxPoints = npts;
+                        // New size is stored 
+
+} /*AliITSDCSDataSDD::SetNPointsMV*/
+
+//---------------------------------------------------------------------------
+void AliITSDCSDataSDD::SetValueTempLeft(Int_t time, Float_t temperature )
+{
+  //
+   if( fTempLeftMaxPoints == fTempLeftSetPoints )
+    SetNPointsTempLeft( fTempLeftMaxPoints + AUTORESIZE );
+                        // Enlarges arrays if necessary
+
+   Int_t i =  FindIndex( time, fTempLeftTimeStamp, fTempLeftSetPoints );
+                        // Finds place where the new value have to be inserted
+
+   if( i < 0 )
+    i = 0;              // New value have to be inserted before the first one in the array
+   else
+    i++;                // New value will be put somewhere in the middle of the array
+                        //  or at the end
+
+   if( i < fTempLeftSetPoints )
+   {
+      Float_t *fromPtrF = fTempLeft.GetArray() + i;
+                       // Sets pointer to cell which have to be filled by new value
+      Float_t *toPtrF = fromPtrF + 1;
+                       // Sets pointer to cell where the array content have to be shifted 
+
+      memmove( toPtrF, fromPtrF, (fTempLeftSetPoints - i)*sizeof(Float_t) );
+                       // Shifts array content. Now there is vacant place for new value to be inserted
+
+      Int_t *fromPtrI = fTempLeftTimeStamp.GetArray() + i;
+      Int_t *toPtrI = fromPtrI + 1;
+      memmove( toPtrI, fromPtrI, (fTempLeftSetPoints - i)*sizeof(Int_t) );
+                       // Do the same for time stamp array
+   } /*if*/
+
+   fTempLeft.AddAt( temperature, i );
+   fTempLeftTimeStamp.AddAt( time, i );
+   fTempLeftSetPoints++;
+                       // New values are inserted
+} /*AliITSDCSDataSDD::SetValueTempLeft*/
+
+//---------------------------------------------------------------------------
+
+void AliITSDCSDataSDD::SetValueTempRight(Int_t time, Float_t temperature )
+{
+  //
+   if( fTempRightMaxPoints == fTempRightSetPoints )
+    SetNPointsTempRight( fTempRightMaxPoints + AUTORESIZE );
+                        // Enlarges arrays if necessary
+
+   Int_t i =  FindIndex( time, fTempRightTimeStamp, fTempRightSetPoints );
+                        // Finds place where the new value have to be inserted
+
+   if( i < 0 )
+    i = 0;              // New value have to be inserted before the first one in the array
+   else
+    i++;                // New value will be put somewhere in the middle of the array
+                        //  or at the end
+
+   if( i < fTempRightSetPoints )
+   {                    // Some values have to be moved
+      Float_t *fromPtrF = fTempRight.GetArray() + i;
+                       // Sets pointer to cell which have to be filled by new value
+      Float_t *toPtrF = fromPtrF + 1;
+                       // Sets pointer to cell where the array content have to be shifted 
+
+      memmove( toPtrF, fromPtrF, (fTempRightSetPoints - i)*sizeof(Float_t) );
+                       // Shifts array content. Now there is vacant place for new value to be inserted
+
+      Int_t *fromPtrI = fTempRightTimeStamp.GetArray() + i;
+      Int_t *toPtrI = fromPtrI + 1;
+      memmove( toPtrI, fromPtrI, (fTempRightSetPoints - i)*sizeof(Int_t) );
+                       // Do the same for time stamp array
+   } /*if*/
+
+   fTempRight.AddAt( temperature, i );
+   fTempRightTimeStamp.AddAt( time, i );
+   fTempRightSetPoints++;
+                       // New values are inserted
+} /*AliITSDCSDataSDD::SetValueTempRight*/
+
+//---------------------------------------------------------------------------
+
+void AliITSDCSDataSDD::SetValueHV(Int_t time, Float_t voltage )
+{
+  //
+   if( fHVMaxPoints == fHVSetPoints )
+    SetNPointsHV( fHVMaxPoints + AUTORESIZE );
+                        // Enlarges arrays if necessary
+
+   Int_t i =  FindIndex( time, fHVTimeStamp, fHVSetPoints );
+                        // Finds place where the new value have to be inserted
+
+   if( i < 0 )
+    i = 0;              // New value have to be inserted before the first one in the array
+   else
+    i++;                // New value will be put somewhere in the middle of the array
+                        //  or at the end
+
+   if( i < fHVSetPoints )
+   {
+      Float_t *fromPtrF = fHV.GetArray() + i;
+                       // Sets pointer to cell which have to be filled by new value
+      Float_t *toPtrF = fromPtrF + 1;
+                       // Sets pointer to cell where the array content have to be shifted 
+
+      memmove( toPtrF, fromPtrF, (fHVSetPoints - i)*sizeof(Float_t) );
+                       // Shifts array content. Now there is vacant place for new value to be inserted
+
+      Int_t *fromPtrI = fHVTimeStamp.GetArray() + i;
+      Int_t *toPtrI = fromPtrI + 1;
+      memmove( toPtrI, fromPtrI, (fHVSetPoints - i)*sizeof(Int_t) );
+                       // Do the same for time stamp array
+   } /*if*/
+
+   fHV.AddAt( voltage, i );
+   fHVTimeStamp.AddAt( time, i );
+   fHVSetPoints++;
+                       // New values are inserted
+} /*AliITSDCSDataSDD::SetValueHV*/
+
+//---------------------------------------------------------------------------
+
+void AliITSDCSDataSDD::SetValueMV(Int_t time, Float_t voltage )
+{
+  //
+   if( fMVMaxPoints == fMVSetPoints )
+    SetNPointsMV( fMVMaxPoints + AUTORESIZE );
+                        // Enlarges arrays if necessary
+
+   Int_t i =  FindIndex( time, fMVTimeStamp, fMVSetPoints );
+                        // Finds place where the new value have to be inserted
+
+   if( i < 0 )
+    i = 0;              // New value have to be inserted before the first one in the array
+   else
+    i++;                // New value will be put somewhere in the middle of the array
+                        //  or at the end
+
+   if( i < fMVSetPoints )
+   {
+      Float_t *fromPtrF = fMV.GetArray() + i;
+                       // Sets pointer to cell which have to be filled by new value
+      Float_t *toPtrF = fromPtrF + 1;
+                       // Sets pointer to cell where the array content have to be shifted 
+
+      memmove( toPtrF, fromPtrF, (fMVSetPoints - i)*sizeof(Float_t) );
+                       // Shifts array content. Now there is vacant place for new value to be inserted
+
+      Int_t *fromPtrI = fMVTimeStamp.GetArray() + i;
+      Int_t *toPtrI = fromPtrI + 1;
+      memmove( toPtrI, fromPtrI, (fMVSetPoints - i)*sizeof(Int_t) );
+                       // Do the same for time stamp array
+   } /*if*/
+
+   fMV.AddAt( voltage, i );
+   fMVTimeStamp.AddAt( time, i );
+   fMVSetPoints++;
+                       // New values are inserted
+} /*AliITSDCSDataSDD::SetValueMV*/
+
+//---------------------------------------------------------------------------
+
+void AliITSDCSDataSDD::SetValueStatus(Int_t time, Char_t status )
+{
+  //
+   if( fStatusMaxPoints == fStatusSetPoints )
+    SetNPointsStatus( fStatusMaxPoints + AUTORESIZE );
+                        // Enlarges arrays if necessary
+
+   Int_t i =  FindIndex( time, fStatusTimeStamp, fStatusSetPoints );
+                        // Finds place where the new value have to be inserted
+
+   if( i < 0 )
+    i = 0;              // New value have to be inserted before the first one in the array
+   else
+    i++;                // New value will be put somewhere in the middle of the array
+                        //  or at the end
+
+   if( i < fStatusSetPoints )
+   {
+      Char_t *fromPtrF = fStatus.GetArray() + i;
+                       // Sets pointer to cell which have to be filled by new value
+      Char_t *toPtrF = fromPtrF + 1;
+                       // Sets pointer to cell where the array content have to be shifted 
+
+      memmove( toPtrF, fromPtrF, (fStatusSetPoints - i)*sizeof(Char_t) );
+                       // Shifts array content. Now there is vacant place for new value to be inserted
+
+      Int_t *fromPtrI = fStatusTimeStamp.GetArray() + i;
+      Int_t *toPtrI = fromPtrI + 1;
+      memmove( toPtrI, fromPtrI, (fStatusSetPoints - i)*sizeof(Int_t) );
+                       // Do the same for time stamp array
+   } /*if*/
+
+   fStatus.AddAt( status, i );
+   fStatusTimeStamp.AddAt( time, i );
+   fStatusSetPoints++;
+                       // New values are inserted
+
+} /*AliITSDCSDataSDD::SetValueStatus*/
+
+
+//---------------------------------------------------------------------------
+
+Float_t AliITSDCSDataSDD::GetTempLeft( Int_t time )
+{ 
+  //
+   Int_t i = FindIndex( time, fTempLeftTimeStamp, fTempLeftSetPoints ); 
+   return ( i < 0 ) ? -1.0 : fTempLeft.At(i); 
+} /*AliITSDCSDataSDD::GetTempLeft*/
+
+Float_t AliITSDCSDataSDD::GetTempRight( Int_t time )
+{ 
+  //
+   Int_t i = FindIndex( time, fTempRightTimeStamp, fTempRightSetPoints ); 
+   return ( i < 0 ) ? -1.0 : fTempRight.At(i); 
+} /*AliITSDCSDataSDD::GetTempRight*/
+
+Float_t AliITSDCSDataSDD::GetHV( Int_t time )
+{
+  //
+   Int_t i = FindIndex( time, fHVTimeStamp, fHVSetPoints ); 
+   return ( i < 0 ) ? -1.0 : fHV.At(i);
+} /*AliITSDCSDataSDD::GetHV*/
+
+Float_t AliITSDCSDataSDD::GetMV( Int_t time )
+{
+  //
+   Int_t i = FindIndex( time, fMVTimeStamp, fMVSetPoints ); 
+   return ( i < 0 ) ? -1.0 : fMV.At(i); 
+} /*AliITSDCSDataSDD::GetMV*/
+
+Char_t AliITSDCSDataSDD::GetStatus( Int_t time )
+{ 
+  //
+   Int_t i = FindIndex( time, fStatusTimeStamp, fStatusSetPoints ); 
+   return ( i < 0 ) ? -1 : fStatus.At(i);
+} /*AliITSDCSDataSDD::GetStatus*/
+
+//---------------------------------------------------------------------------
+
+void AliITSDCSDataSDD::Compress()
+{
+  // Tries to minimize array sizes
+
+   SetNPointsTempLeft( fTempLeftSetPoints );
+   SetNPointsTempRight( fTempRightSetPoints );
+   SetNPointsHV( fHVSetPoints );
+   SetNPointsMV( fMVSetPoints );
+   SetNPointsStatus( fStatusSetPoints );
+
+} /*AliITSDCSDataSDD::Compress*/
+
+//---------------------------------------------------------------------------
+
+Float_t AliITSDCSDataSDD::GetDriftField( Int_t timeStamp )
+{                      
+// Returns drift field counted for specific time
+
+   Int_t   cathodesNumber = 291;
+   Float_t cathodesPitch = 0.0120;
+
+   Float_t hv = GetHV( timeStamp );
+   Float_t mv = GetMV( timeStamp );
+
+   if( hv < 0.0 || mv < 0.0 ) return -1.0;
+                        // HV or MV is unknown at this time
+
+   return ( hv - mv ) / ( cathodesNumber * cathodesPitch );
+
+} /*AliITSDCSDataSDD::GetDriftField*/
+
+//---------------------------------------------------------------------------
+
+
+Float_t AliITSDCSDataSDD::GetDriftSpeed( Int_t /*timeStamp*/ ) const
+{                      
+// Returns drift speed counted for specific time. This metod is not dedicated
+//  for normal usage - it should be used only in cases that the injectors for
+                       //  given module fails
+
+   /* PROTOTYPE */
+
+   return -1.0;
+
+} /*AliITSDCSDataSDD::*/
+
+//---------------------------------------------------------------------------
+
+
+void AliITSDCSDataSDD:: PrintValues( FILE *output ) const
+{                       
+// Prints array contents
+
+    Int_t nTLEntries = GetTempLeftRecords();
+    Int_t nTREntries = GetTempRightRecords();
+    Int_t nHVEntries = GetHVRecords() ;
+    Int_t nMVEntries = GetMVRecords();
+    Int_t nStatEntries = GetStatusRecords();
+
+    fprintf( output, "+-----------------------------------------------------------------------------------------------------------+\n");
+    fprintf( output, "|                                               DCS content                                                 |\n" ); 
+    fprintf( output, "+----------------------+----------------------+---------------------+---------------------+-----------------+\n");
+    fprintf( output, "|    %05i  records    |    %05i  records    |    %05i  records   |    %05i  records   |  %05i records  |\n",
+                          nHVEntries, nMVEntries, nTLEntries, nTREntries, nStatEntries );
+    fprintf( output, "|  time (s)     HV     |  time (s)      MV    |  time (s)     TL    |  time (s)     TR    | time (s)   Stat |\n" );
+    fprintf( output, "+----------------------+----------------------+---------------------+---------------------+-----------------+\n");
+
+    Int_t a = (nHVEntries > nMVEntries ) ? nHVEntries : nMVEntries;
+    Int_t b = (nTLEntries > nTREntries ) ? nTLEntries : nTREntries;
+    if( a < b ) a = b;
+    Int_t loopMax = ( a > nStatEntries ) ? a : nStatEntries ;
+                 // Finds maximal entry number
+
+    for( Int_t entryLoop = 0; entryLoop < loopMax; entryLoop++ )
+    {
+
+        if( entryLoop < nHVEntries )
+         fprintf( output, "| %12i %4.2f | ", GetHVTimeIdx(entryLoop), GetHVIdx(entryLoop) );
+        else
+         fprintf( output, "|                      | ");
+
+        if( entryLoop < nMVEntries )
+         fprintf( output, " %12i  %2.2f | ", GetMVTimeIdx(entryLoop), GetMVIdx(entryLoop) );
+        else
+         fprintf( output, "                     | ");
+
+        if( entryLoop < nTLEntries )
+         fprintf( output, "%12i  %2.2f | ", GetTempLeftTimeIdx(entryLoop), GetTempLeftIdx(entryLoop) );
+        else
+         fprintf( output, "                    | ");
+
+        if( entryLoop < nTREntries )
+         fprintf( output, "%12i  %2.2f | ", GetTempRightTimeIdx(entryLoop), GetTempRightIdx(entryLoop) );
+        else
+         fprintf( output, "                    | ");
+
+        if( entryLoop < nStatEntries )
+         fprintf( output, "%12i  %i |\n", GetStatusTimeIdx(entryLoop), GetStatusIdx(entryLoop) );
+        else
+         fprintf( output, "                |\n");
+
+    } /*for( entryLoop )*/
+
+
+} /*AliITSDCSDataSDD::PrintValues()*/
+
+//---------------------------------------------------------------------------
+
+Int_t AliITSDCSDataSDD::FindIndex( Int_t time, TArrayI &timeArray, Int_t n ) const
+{                       
+// Provides binary search in the time array
+
+  if( n < 1 ) return -1;// Empty array or wrong value of array size
+
+  if( time >= timeArray.At(n-1) ) return n-1;
+                        // Time is larger than last timestamp - last value in the array have
+                        //  to be used. This is the most frequent case, so it have sense
+                        //  to check it and avoid searching.
+
+  if( time < timeArray.At(0) ) return -1;
+                        // Time is less than all time stamp stored in the array
+
+  Int_t left = 0;
+  Int_t right = n-1;
+  Int_t middle = (left + right)/2;
+
+  while( !( middle == left || middle == right) )
+  {                     // Binary search in the time stamp array
+
+     if( timeArray.At(middle) < time )
+      left = middle;
+     else
+      right = middle;
+     middle = (left + right)/2;
+  } /*while*/
+
+  if( time >= timeArray.At(right) )
+   return right;
+  else
+   return left;
+
+} /*AliITSDCSDataSDD::FindIndexByTimeStamp*/
+
+//---------------------------------------------------------------------------
index 77d268f..7813d90 100644 (file)
 //                                                               //
 // Class to define object containing SDD DCS data                //
 // Origin: F.Prino, Torino, prino@to.infn.it                     //
-//                                                               //
+//         V.Pospisil, CTU Prague, gdermog@seznam.cz             //
 ///////////////////////////////////////////////////////////////////
 
 #include<TObject.h>
 #include<TArrayF.h>
 #include<TArrayI.h>
+#include<TArrayC.h>
 
-class AliITSDCSDataSDD : public TObject { 
+class AliITSDCSDataSDD : public TObject 
+{ 
 
  public:
-  AliITSDCSDataSDD();
-  AliITSDCSDataSDD(Int_t npts);
-  ~AliITSDCSDataSDD(){};
-  void SetNPoints(Int_t npts);
-  void SetValues(Int_t time, Float_t field, Float_t templ, Float_t tempr);
-  void Compress();
-
-  Int_t GetNumberOfValues() const {return fSetPoints;}
-  Int_t GetTimeStamp(Int_t i) const {return fTimeStamp.At(i);}
-  Float_t GetDriftField(Int_t i) const {return fDriftField.At(i);}
-  Float_t GetLeftTemperature(Int_t i) const {return fTemperatureLeft.At(i);}
-  Float_t GetRightTemperature(Int_t i) const {return fTemperatureRight.At(i);}
-  void PrintValues() const;
+  AliITSDCSDataSDD( void );
+                        // Default constructor
+  ~AliITSDCSDataSDD( void ){};
+                        // Destructor is void
+
+  void SetNPointsTempLeft( Int_t npts );
+  void SetNPointsTempRight( Int_t npts );
+  void SetNPointsHV( Int_t npts );
+  void SetNPointsMV( Int_t npts );
+  void SetNPointsStatus( Int_t npts );
+                        // Sets sizes of the DCS variable arrays
+
+  void SetValueTempLeft(Int_t time, Float_t temperature );
+  void SetValueTempRight(Int_t time, Float_t temperature );
+  void SetValueHV(Int_t time, Float_t voltage );
+  void SetValueMV(Int_t time, Float_t voltage );
+  void SetValueStatus(Int_t time, Char_t status );
+                        // Inserts value of a DCS variable into the appropriate array.
+                        //  Resizes and sorts array if necessary.
+
+  void Compress();      // Tries to minimize array sizes
+
+  Int_t GetTempLeftRecords()  const {return fTempLeftSetPoints;}
+  Int_t GetTempRightRecords() const {return fTempRightSetPoints;}
+  Int_t GetHVRecords()        const {return fHVSetPoints;}
+  Int_t GetMVRecords()        const {return fMVSetPoints;}
+  Int_t GetStatusRecords()    const {return fStatusSetPoints;}
+                       // Returns number of stored values of specific DCS variable
+
+  Int_t GetTempLeftSize()  const {return fTempLeftMaxPoints;}
+  Int_t GetTempRightSize() const {return fTempRightMaxPoints;}
+  Int_t GetHVSize()        const {return fHVMaxPoints;}
+  Int_t GetMVSize()        const {return fMVMaxPoints;}
+  Int_t GetStatusSize()    const {return fStatusMaxPoints;}
+                       // Returns size of selected array
+
+  Float_t GetTempLeftIdx( Int_t index )  const {return fTempLeft.At(index);};
+  Float_t GetTempRightIdx( Int_t index ) const {return fTempRight.At(index);};
+  Float_t GetHVIdx( Int_t index )        const {return fHV.At(index);};
+  Float_t GetMVIdx( Int_t index )        const {return fMV.At(index);};
+  Char_t  GetStatusIdx( Int_t index )    const {return fStatus.At(index);};
+                       // Returns value of specific DCS variable by index in the array
+
+  Bool_t GetOKStatIdx( Int_t index )        const { return (Bool_t)(fStatus.At(index) & 1 ); };
+  Bool_t GetTempLeftStatIdx( Int_t index )  const { return (Bool_t)(fStatus.At(index) & 2 ); };
+  Bool_t GetTempRightStatIdx( Int_t index ) const { return (Bool_t)(fStatus.At(index) & 4 ); };
+                       // Return status of a readout device by index in the array
+
+  Int_t   GetTempLeftTimeIdx( Int_t index )  const {return fTempLeftTimeStamp.At(index);};
+  Int_t   GetTempRightTimeIdx( Int_t index ) const {return fTempRightTimeStamp.At(index);};
+  Int_t   GetHVTimeIdx( Int_t index )        const {return fHVTimeStamp.At(index);};
+  Int_t   GetMVTimeIdx( Int_t index )        const {return fMVTimeStamp.At(index);};
+  Int_t   GetStatusTimeIdx( Int_t index )    const {return fStatusTimeStamp.At(index);};
+                       // Returns time stamp of specific DCS variable by index in the array
+
+  Float_t GetTempLeft( Int_t time );
+  Float_t GetTempRight( Int_t time );
+  Float_t GetHV( Int_t time );
+  Float_t GetMV( Int_t time );
+  Char_t  GetStatus( Int_t time );
+                       // Returns value of specific DCS variable by time stamp
+
+  Bool_t GetOKStat( Int_t time )        { Char_t stat = GetStatus( time ); return (Bool_t)( stat & 1 ); };
+  Bool_t GetTempLeftStat( Int_t time )  { Char_t stat = GetStatus( time ); return (Bool_t)( stat & 2 ); };
+  Bool_t GetTempRightStat( Int_t time ) { Char_t stat = GetStatus( time ); return (Bool_t)( stat & 4 ); };
+                       // Return status of a readout device in given time
+
+  Float_t GetDriftField( Int_t timeStamp );
+                       // Returns drift field counted for specific time
 
+  Float_t GetDriftSpeed( Int_t timeStamp ) const;
+                       // Returns drift speed counted for specific time. This metod is not dedicated
+                       //  for normal usage - it should be used only in cases that the injectors for
+                       //  given module fails
+
+  void PrintValues( FILE *output = stdout ) const;
+                       // Displays stored DCS varable values or writes it into a text file
  private:
 
+  TArrayF fTempLeft;              //|| "don't split" automatic streamer instruction
+                        // Temperature on left side. If there is stored a negative value
+                        //  something wrong happend with the temperature chip.
+  TArrayI fTempLeftTimeStamp;     //||
+                        // Time stamps of the temperatures on left side
+  Int_t   fTempLeftMaxPoints;    // Size of the arrays
+  Int_t   fTempLeftSetPoints;    // Number of filled array cells (number of set values)
+
+
+  TArrayF fTempRight;             //||
+                        // Temperature on right side. If there is stored a negative value
+                        //  something wrong happend with the temperature chip.
+  TArrayI fTempRightTimeStamp;    //||
+                        // Time stamps of temperatures on right side
+  Int_t   fTempRightMaxPoints;    // Size of the arrays
+  Int_t   fTempRightSetPoints;    // Number of filled array cells (number of set values)
+
+
+  TArrayF fHV;                    //||
+                        // High voltage on SDD
+  TArrayI fHVTimeStamp;           //||
+                        // Time stamps of HV
+  Int_t   fHVMaxPoints; // Size of the arrays
+  Int_t   fHVSetPoints; // Number of filled array cells (number of set values)
+
+
+  TArrayF fMV;                    //||
+                        // Medium voltage on SDD
+  TArrayI fMVTimeStamp;           //||
+                        // Time stamps of MV
+  Int_t   fMVMaxPoints; // Size of the arrays
+  Int_t   fMVSetPoints; // Number of filled array cells (number of set values)
+
+
+  TArrayC fStatus;                //||
+                        // Status of temperature and voltage readout
+                        //
+                        // bit 0 - _OK
+                        // bit 1 - _TEMP_L_STATE
+                        // bit 2 - _TEMP_R_STATE
+
+  TArrayI fStatusTimeStamp;       //||
+                        // Time stamps of MV
+  Int_t   fStatusMaxPoints; // Size of the arrays
+  Int_t   fStatusSetPoints; // Number of filled array cells (number of set values)
+
+
+  Int_t   FindIndex( Int_t timeStamp, TArrayI &timeStampArray, Int_t n ) const;
+                        // Returns index in the array of time stamps by selected value. Returns -1
+                        //  if the time is less than time stamp in the timeArray[0]
 
-  Int_t fNpts;   // number of values for DCS data points
-  Int_t fSetPoints; // number of set values
-  TArrayI fTimeStamp; // DCS time stamp
-  TArrayF fDriftField; // drift field (calculated from HV and MV)
-  TArrayF fTemperatureLeft; // temperature from sensor on left hybrid
-  TArrayF fTemperatureRight; // temperature from sensor on right hybrid
+  ClassDef(AliITSDCSDataSDD, 2)
 
-  ClassDef(AliITSDCSDataSDD, 1);
-};
+}; /*class AliITSDCSDataSDD*/
 
 #endif
diff --git a/ITS/CreateSDDDCSMap.C b/ITS/CreateSDDDCSMap.C
new file mode 100644 (file)
index 0000000..1994db8
--- /dev/null
@@ -0,0 +1,741 @@
+#if !defined(__CINT__) || defined(__MAKECINT__)
+#include <TTimeStamp.h>
+#include <TMap.h>
+#include <TMath.h>
+#include <TFile.h>
+#include <TObjArray.h>
+#include <TObjString.h>
+#include <TRandom.h>
+#include <TSystem.h>
+#include <AliDCSValue.h>
+#endif
+
+
+//////////////////////////////////////////////////////////////////////////////////////
+// Generator of testing data for AliITSDCSPreprocessorSDD and  AliITSAnalyzerrSDD   //
+// Origin: F.Prino, Torino, prino@to.infn.it                                        //
+//         V.Pospisil, CTU Prague, gdermog@seznam.cz                                //
+//////////////////////////////////////////////////////////////////////////////////////
+
+
+TMap* CreateRealisticMap( TTimeStamp startTime, TTimeStamp stopTime );
+TMap* CreateRandomMap( Int_t maxRecords = 1000, Int_t randomTimeStamps = 0 );
+void GenerateOutputFiles( TMap *map, char *dir );
+
+
+void CreateSDDDCSMap( void )
+{
+
+ TTimeStamp startT( 2008, 2, 7, 15, 0, 0 );
+ TTimeStamp stopT( 2008, 2, 7, 18, 0, 0 );
+                        // The beginning and the end of the simulated run
+
+//  delete gRandom;
+//  gRandom = new TRandom2;
+ gRandom->SetSeed(0);
+
+/* Macro can generate random purely random data or simulate DCS. Choose
+   one of the methods - CreateRandomMap() or CreateRealisticMap() */
+
+// TMap *outMap = CreateRandomMap( 1000 );
+ TMap *outMap = CreateRealisticMap( startT, stopT );
+
+ GenerateOutputFiles( outMap, "./maps_3h_SIM" );
+
+ TFile newfile( "DCSAliasMap_3h_SIM.root", "RECREATE" );
+
+ printf( "Writting map into the file ...\n");
+
+ outMap->Write( "DCSAliasMap", TObject::kSingleKey );
+
+ printf( "DCSAliasMap created...\n");
+
+} /*CreateMap*/
+
+
+/***************************************************************/
+/*     DCS simulation setup - used in CreateRealisticMap()     */
+/*   Choose simulation setup by changing following variables   */
+/***************************************************************/
+
+// --- Temperature (left side) - behavior of SDD chip -----------
+
+ Float_t mvalTL = 20.0; // Mean value of temperature
+ Float_t fluctTL = 0.5; // Fluctuation (gaussian sigma)
+
+// --- Temperature readout (left side) - behavior of DCS --------
+
+ Int_t freqROTL = 60;   // Frequency of fixed readout
+ Float_t fluctROTL = 5.0;
+                        // Allowed fluctuation (%)
+
+// Temperature readout status (left side) - behavior of SDD chip
+
+  Int_t freqROStTL = 60;// Frequency of fixed readout
+  Float_t failureTL = 0.01;
+                        // Probability of thermometer
+                        //  failure (in one hour)
+
+// --- Temperature (right side) - behavior of SDD chip ----------
+
+ Float_t mvalTR = 20.0; // Mean value of temperature
+ Float_t fluctTR = 0.5;// Fluctuation (gaussian sigma)
+
+// --- Temperature readout (right side) - behavior of DCS -------
+
+ Int_t freqROTR = 60;   // Frequency of fixed readout
+ Float_t fluctROTR = 5.0;
+                        // Allowed fluctuation (%)
+
+// Temperature readout status (right side) - behavior of SDD
+
+  Int_t freqROStTR = 60;// Frequency of fixed readout
+  Float_t failureTR = 0.01;
+                        // Probability of thermometer
+                        //  failure (in one hour) 
+
+// --- High voltage  - behavior of SDD voltage source -----------
+
+ Float_t mvalHV = 1791.0;
+                        // Mean value of HV
+ Float_t fluctHV = 0.5; // Fluctuation (gaussian sigma)
+
+// --- High voltage readout - behavior of DCS -------------------
+
+ Int_t freqROHV = 60;   // Frequency of fixed readout
+ Float_t fluctROHV = 0.01;
+                        // Allowed fluctuation (%)
+
+// --- High voltage readout status - behavior of SDD voltage ----
+
+  Int_t freqROOK = 60;  // Frequency of fixed readout
+  Float_t failureHV  = 0.005;
+                        // Probability of HV source
+                        //  failure (in one hour) 
+
+// --- Medium voltage  - behavior of SDD voltage source --------
+
+ Float_t mvalMV = 45.0; // Mean value of MV
+ Float_t fluctMV = 0.25;// Fluctuation (gaussian sigma)
+
+// --- Medium voltage readout - behavior of DCS -----------------
+
+ Int_t freqROMV = 60;   // Frequency of fixed readout
+ Float_t fluctROMV = 0.1;
+                        // Allowed fluctuation (%)
+
+// --- Medium voltage readout status - behavior of SDD voltage --
+
+ Float_t failureMV  = 0.005;
+                        // Probability of MV source
+                        //  failure (in one hour)
+
+/***************************************************************/
+/*   ITS geometry setup                                        */
+/***************************************************************/
+
+ Int_t kNladders3=14;
+ Int_t kNladders4=22;
+ Int_t kNmodLad3=6;
+ Int_t kNmodLad4=8;
+
+/***************************************************************/
+
+//----------------------------------------------------------------------------------------
+
+TMap* CreateRealisticMap( TTimeStamp startTime, TTimeStamp stopTime )
+{
+  // Creates a DCS structure
+  // The structure is the following:
+  //   TMap (key --> value)
+  //     <DCSAlias> --> <valueList>
+  //     <DCSAlias> is a string
+  //     <valueList> is a TObjArray of AliDCSValue
+  //     An AliDCSValue consists of timestamp and a value in form of a AliSimpleValue
+
+  TMap* aliasMap = new TMap;
+  aliasMap->SetOwner(1);
+                        // Empty map is created
+
+  TString aliasName;
+  Char_t dpName[50];
+  Int_t created = 0;
+  Int_t created1 = 0;   // DCS records counter
+
+  Double_t failureTLpersec;
+  Double_t failureTRpersec;
+  Double_t failureHVpersec;
+  Double_t failureMVpersec;
+                        // Probabilities of failure per one second
+  Double_t lambda;
+  lambda = ( TMath::Log( 1.0 - failureTL ) ) / -3600.0;
+  failureTLpersec = 1.0 - TMath::Exp(-lambda );
+  lambda = ( TMath::Log( 1.0 - failureTR ) ) / -3600.0;
+  failureTRpersec = 1.0 - TMath::Exp(-lambda );
+  lambda = ( TMath::Log( 1.0 - failureHV ) ) / -3600.0;
+  failureHVpersec = 1.0 - TMath::Exp(-lambda );
+  lambda = ( TMath::Log( 1.0 - failureMV ) ) / -3600.0;
+  failureMVpersec = 1.0 - TMath::Exp(-lambda );
+                        // Probabilities of failure per one second are counted
+
+  fluctROTL /= 100.0;
+  fluctROTR /= 100.0;
+  fluctROHV /= 100.0;
+  fluctROMV /= 100.0;   // Percents to fractions
+
+  Double_t failureOK = ( failureHV + failureMV ) / 2.0;
+                        // This value is used only for noise in timing
+
+  for( Int_t iLay = 3; iLay < 5; iLay++ )
+  {
+
+      Int_t maxLad = ( iLay == 3) ? kNladders3 : kNladders4;
+      Int_t maxMod = ( iLay == 3) ? kNmodLad3 : kNmodLad4;
+
+      for(Int_t iLad=0; iLad<maxLad; iLad++)
+      {
+         for(Int_t iMod=0; iMod<maxMod; iMod++)
+         {
+
+            fprintf( stderr, "Simulating data taking for layer %i, ladder %i, module %i ... \n", iLay, iLad, iMod );
+
+            TObjArray* valueSetOK = new TObjArray;
+            TObjArray* valueSetHV = new TObjArray;
+            TObjArray* valueSetMV = new TObjArray;
+            TObjArray* valueSetTL = new TObjArray;
+            TObjArray* valueSetTR = new TObjArray;
+            TObjArray* valueSetStTL = new TObjArray;
+            TObjArray* valueSetStTR = new TObjArray;
+
+            valueSetOK->SetOwner(1);
+            valueSetHV->SetOwner(1);
+            valueSetMV->SetOwner(1);
+            valueSetTL->SetOwner(1);
+            valueSetTR->SetOwner(1);
+            valueSetStTL->SetOwner(1);
+            valueSetStTR->SetOwner(1);
+
+            Float_t actualTL, actualTR;
+            Float_t actualHV, actualMV;
+            Int_t   actualStTL = 1;
+            Int_t   actualStTR = 1;
+            Int_t   actualStHV = 1;
+            Int_t   actualStMV = 1;
+                             // Readout devices are alive/dead
+
+            Float_t lastTL = mvalTL;
+            Float_t lastTR = mvalTR;
+            Float_t lastHV = mvalHV;
+            Float_t lastMV = mvalMV;
+                             // Last written values - udes for threshold readout
+
+            Int_t counterTL = 0;
+            Int_t counterTR = 0;
+            Int_t counterHV = 0;
+            Int_t counterMV = 0;
+            Int_t counterStTL = 0;
+            Int_t counterStTR = 0;
+            Int_t counterOK = 0;
+                              // Periodic readout counters
+
+            Int_t endingTimeStamp = stopTime.GetSec();
+
+            for( Int_t timeLoop = startTime.GetSec(); timeLoop < endingTimeStamp; timeLoop ++ )
+            {                 // Loop goes through period of run second per second and determines
+                              //  all values according to rules of DCS
+
+               actualTL = gRandom->Gaus( mvalTL, fluctTL );
+               actualTR = gRandom->Gaus( mvalTR, fluctTR );
+               actualHV = gRandom->Gaus( mvalHV, fluctHV );
+               actualMV = gRandom->Gaus( mvalMV, fluctMV );
+                              // Generates random values of temperatures and voltages
+                              //  in given ranges
+
+               if( gRandom->Rndm() < failureTLpersec ) 
+                if( actualStTL ) actualStTL = 0; else if( gRandom->Rndm() < 0.1 ) actualStTL = 1;
+               if( gRandom->Rndm() < failureTRpersec ) 
+                if( actualStTR ) actualStTR = 0; else if( gRandom->Rndm() < 0.1 ) actualStTR = 1;
+               if( gRandom->Rndm() < failureHVpersec ) 
+                if( actualStHV ) actualStHV = 0; else if( gRandom->Rndm() < 0.1 ) actualStHV = 1;
+               if( gRandom->Rndm() < failureMVpersec ) 
+                if( actualStMV ) actualStMV = 0; else if( gRandom->Rndm() < 0.1 ) actualStMV = 1;
+                              // Decides if any thermometer or voltage source becomes 
+                              //  dead (or alive again, but this have much 10x les probability )
+
+               if( gRandom->Rndm() < failureTL ) counterTL++;
+               if( gRandom->Rndm() < failureTL ) counterTL--;
+               if( gRandom->Rndm() < failureTR ) counterTR++;
+               if( gRandom->Rndm() < failureTR ) counterTR--;
+               if( gRandom->Rndm() < failureHV ) counterHV++;
+               if( gRandom->Rndm() < failureHV ) counterHV--;
+               if( gRandom->Rndm() < failureMV ) counterMV++;
+               if( gRandom->Rndm() < failureMV ) counterMV--;
+               if( gRandom->Rndm() < failureTL ) counterStTL++;
+               if( gRandom->Rndm() < failureTL ) counterStTL--;
+               if( gRandom->Rndm() < failureTR ) counterStTR++;
+               if( gRandom->Rndm() < failureTR ) counterStTR--;
+               if( gRandom->Rndm() < failureOK ) counterOK++;
+               if( gRandom->Rndm() < failureOK ) counterOK--;
+                        // Simulating noise in the clock frequency
+
+               if( counterTL >= freqROTL )
+                { valueSetTL->Add( new AliDCSValue( actualTL, timeLoop ) ); lastTL = actualTL; counterTL = 0; created++; }
+               if( counterTR >= freqROTR )
+                { valueSetTR->Add( new AliDCSValue( actualTR, timeLoop ) ); lastTR = actualTR; counterTR = 0; created++; }
+               if( counterHV >= freqROHV )
+                { valueSetHV->Add( new AliDCSValue( actualHV, timeLoop ) ); lastHV = actualHV; counterHV = 0; created++; }
+               if( counterMV >= freqROMV )
+                { valueSetMV->Add( new AliDCSValue( actualMV, timeLoop ) ); lastMV = actualMV; counterMV = 0; created++; }
+               if( counterStTL >= freqROStTL )
+                { valueSetStTL->Add( new AliDCSValue( actualStTL, timeLoop ) ); counterStTL = 0; created++; }
+               if( counterStTR >= freqROStTR )
+                { valueSetStTR->Add( new AliDCSValue( actualStTR, timeLoop ) ); counterStTR = 0; created++; }
+               if( counterOK >= freqROOK )
+                { valueSetOK->Add( new AliDCSValue( (Bool_t)(actualStHV & actualStMV), timeLoop ) ); counterOK = 0; created++; }
+                        // Periodic readout
+
+               if( TMath::Abs( (lastTL - actualTL) / lastTL ) > fluctROTL )
+                { valueSetTL->Add( new AliDCSValue( actualTL, timeLoop ) ); lastTL = actualTL; counterTL = 0; created1++; }
+               if( TMath::Abs( (lastTR - actualTR) / lastTR ) > fluctROTR )
+                { valueSetTR->Add( new AliDCSValue( actualTR, timeLoop ) ); lastTR = actualTR; counterTR = 0; created1++; }
+               if( TMath::Abs( (lastHV - actualHV) / lastHV ) > fluctROHV )
+                { valueSetHV->Add( new AliDCSValue( actualHV, timeLoop ) ); lastHV = actualHV; counterHV = 0; created1++; }
+               if( TMath::Abs( (lastMV - actualMV) / lastMV ) > fluctROMV )
+                { valueSetMV->Add( new AliDCSValue( actualMV, timeLoop ) ); lastMV = actualMV; counterMV = 0; created1++; }
+                        // Treshold readout
+
+               counterTL++;
+               counterTR++;
+               counterHV++;
+               counterMV++;
+               counterStTL++;
+               counterStTR++;
+               counterOK++;
+
+            } /*for( timeLoop )*/
+
+            sprintf( dpName, "SDD_LAYER%i_LADDER%02d_MODULE%d_OK", iLay, iLad, iMod );
+            aliasName = dpName;
+            aliasMap->Add( new TObjString(aliasName), valueSetOK );
+
+            sprintf( dpName, "SDD_LAYER%i_LADDER%02d_MODULE%d_HV", iLay, iLad, iMod );
+            aliasName = dpName;
+            aliasMap->Add( new TObjString(aliasName), valueSetHV );
+
+            sprintf( dpName, "SDD_LAYER%i_LADDER%02d_MODULE%d_MV", iLay, iLad, iMod );
+            aliasName = dpName;
+            aliasMap->Add( new TObjString(aliasName), valueSetMV );
+
+            sprintf( dpName, "SDD_LAYER%i_LADDER%02d_MODULE%d_TEMP_L", iLay, iLad, iMod );
+            aliasName = dpName;
+            aliasMap->Add( new TObjString(aliasName), valueSetTL );
+
+            sprintf( dpName, "SDD_LAYER%i_LADDER%02d_MODULE%d_TEMP_R", iLay, iLad, iMod );
+            aliasName = dpName;
+            aliasMap->Add( new TObjString(aliasName), valueSetTR );
+
+            sprintf( dpName, "SDD_LAYER%i_LADDER%02d_MODULE%d_TEMP_L_STATE", iLay, iLad, iMod );
+            aliasName = dpName;
+            aliasMap->Add( new TObjString(aliasName), valueSetStTL );
+
+            sprintf( dpName, "SDD_LAYER%i_LADDER%02d_MODULE%d_TEMP_R_STATE", iLay, iLad, iMod );
+            aliasName = dpName;
+            aliasMap->Add( new TObjString(aliasName), valueSetStTR );
+
+         } /*for( iMod ) */
+      } /*for( iLad )*/
+  } /*for( iLay )*/
+
+  fprintf(  stderr, "\nCreated %i objects of type AliDCSValue (%i periodic + %i treshold)... \n", 
+            created + created1, created, created1 );
+
+  return aliasMap;
+
+} /*CreateRealisticMap*/
+
+//----------------------------------------------------------------------------------------
+
+
+TMap* CreateRandomMap( Int_t maxRecords , Int_t randomTimeStamps  )
+{
+  // Creates a DCS structure
+  // The structure is the following:
+  //   TMap (key --> value)
+  //     <DCSAlias> --> <valueList>
+  //     <DCSAlias> is a string
+  //     <valueList> is a TObjArray of AliDCSValue
+  //     An AliDCSValue consists of timestamp and a value in form of a AliSimpleValue
+
+
+  TMap* aliasMap = new TMap;
+  aliasMap->SetOwner(1);
+
+
+  TString aliasName;
+  Char_t dpName[50];
+  Int_t created = 0;
+
+  for( Int_t iLay = 3; iLay < 5; iLay++ )
+  {
+
+      Int_t maxLad = ( iLay == 3) ? kNladders3 : kNladders4;
+      Int_t maxMod = ( iLay == 3) ? kNmodLad3 : kNmodLad4;
+
+      for(Int_t iLad = 0; iLad < maxLad; iLad++)
+      {
+         for(Int_t iMod =0 ; iMod < maxMod;iMod++)
+         {
+
+            fprintf( stderr, "Generating data for layer %i, ladder %i, module %i ... \n", iLay, iLad, iMod );
+
+            TObjArray* valueSetOK = new TObjArray;
+            TObjArray* valueSetH = new TObjArray;
+            TObjArray* valueSetM = new TObjArray;
+            TObjArray* valueSetTL = new TObjArray;
+            TObjArray* valueSetTR = new TObjArray;
+            TObjArray* valueSetStTL = new TObjArray;
+            TObjArray* valueSetStTR = new TObjArray;
+
+            valueSetOK->SetOwner(1);
+            valueSetH->SetOwner(1);
+            valueSetM->SetOwner(1);
+            valueSetTL->SetOwner(1);
+            valueSetTR->SetOwner(1);
+            valueSetStTL->SetOwner(1);
+            valueSetStTR->SetOwner(1);
+
+            Int_t nrOfRecords;
+            AliDCSValue* dcsVal;
+            Int_t timeStamp;
+
+            sprintf(dpName,"SDD_LAYER%i_LADDER%02d_MODULE%d_OK", iLay,iLad,iMod);
+            aliasName=dpName;
+            nrOfRecords = (Int_t)(maxRecords * ( gRandom->Rndm() ) );
+            timeStamp = 1000000000;
+            for( Int_t recLoop = 0; recLoop < nrOfRecords; recLoop ++ )
+            {
+               if( randomTimeStamps )
+                timeStamp = (Int_t)(1200000000*(gRandom->Rndm()));
+               else
+                timeStamp += (Int_t)(50*(gRandom->Rndm()) );
+            if( 1000*(gRandom->Rndm()) > 50 ) 
+               dcsVal = new AliDCSValue((Bool_t)1, timeStamp);
+            else
+               dcsVal = new AliDCSValue((Bool_t)0, timeStamp);
+            valueSetOK->Add(dcsVal);
+
+            } /*for( recLoop )*/
+            aliasMap->Add(new TObjString(aliasName), valueSetOK);
+            created += nrOfRecords;
+
+            sprintf(dpName,"SDD_LAYER%i_LADDER%02d_MODULE%d_HV", iLay, iLad,iMod);
+            aliasName=dpName;
+            nrOfRecords = (Int_t)(maxRecords * ( gRandom->Rndm() ));
+            timeStamp = 1000000000;
+            for( Int_t recLoop = 0; recLoop < nrOfRecords; recLoop ++ )
+            {
+               if( randomTimeStamps )
+               timeStamp = (Int_t)(1200000000*(gRandom->Rndm()));
+               else
+               timeStamp += (Int_t)(50*(gRandom->Rndm()) );
+               dcsVal = new AliDCSValue( (Float_t)( 1600 + 200*(gRandom->Rndm()) ), timeStamp );
+               valueSetH->Add(dcsVal);
+
+            } /*for( recLoop )*/
+            aliasMap->Add(new TObjString(aliasName), valueSetH);
+            created += nrOfRecords;
+
+            sprintf(dpName,"SDD_LAYER%i_LADDER%02d_MODULE%d_MV", iLay, iLad,iMod);
+            aliasName=dpName;
+            nrOfRecords = (Int_t)(maxRecords * ( gRandom->Rndm() ));
+            timeStamp = 1000000000;
+            for( Int_t recLoop = 0; recLoop < nrOfRecords; recLoop ++ )
+            {
+               if( randomTimeStamps )
+               timeStamp = (Int_t)(1200000000*(gRandom->Rndm()));
+               else
+               timeStamp += (Int_t)(50*(gRandom->Rndm()) );
+               dcsVal = new AliDCSValue( (Float_t)( 30 + 20*(gRandom->Rndm()) ), timeStamp );
+               valueSetM->Add(dcsVal);
+            } /*for( recLoop )*/
+            aliasMap->Add(new TObjString(aliasName), valueSetM);
+            created += nrOfRecords;
+
+            sprintf(dpName,"SDD_LAYER%i_LADDER%02d_MODULE%d_TEMP_L", iLay, iLad,iMod);
+            aliasName=dpName;
+            nrOfRecords = (Int_t)(maxRecords * ( gRandom->Rndm() ));
+            timeStamp = 1000000000;
+            for( Int_t recLoop = 0; recLoop < nrOfRecords; recLoop ++ )
+            {
+               if( randomTimeStamps )
+               timeStamp = (Int_t)(1200000000*(gRandom->Rndm()));
+               else
+               timeStamp += (Int_t)(50*(gRandom->Rndm()) );
+               dcsVal = new AliDCSValue( (Float_t)( 50 + 50*(gRandom->Rndm()) ), timeStamp );
+               valueSetTL->Add(dcsVal);
+            } /*for( recLoop )*/
+            aliasMap->Add(new TObjString(aliasName), valueSetTL);
+            created += nrOfRecords;
+
+            sprintf(dpName,"SDD_LAYER%i_LADDER%02d_MODULE%d_TEMP_R", iLay, iLad,iMod);
+            aliasName=dpName;
+            nrOfRecords = (Int_t)(maxRecords * ( gRandom->Rndm() ));
+            timeStamp = 1000000000;
+            for( Int_t recLoop = 0; recLoop < nrOfRecords; recLoop ++ )
+            {
+               if( randomTimeStamps )
+               timeStamp = (Int_t)(1200000000*(gRandom->Rndm()));
+               else
+               timeStamp += (Int_t)(50*(gRandom->Rndm()) );
+               dcsVal = new AliDCSValue( (Float_t)( 50 + 50*(gRandom->Rndm()) ), timeStamp );
+               valueSetTR->Add(dcsVal);
+            } /*for( recLoop )*/
+            aliasMap->Add(new TObjString(aliasName), valueSetTR);
+            created += nrOfRecords;
+
+            sprintf(dpName,"SDD_LAYER%i_LADDER%02d_MODULE%d_TEMP_L_STATE", iLay, iLad,iMod);
+            aliasName=dpName;
+            nrOfRecords = (Int_t)(maxRecords * ( gRandom->Rndm() ));
+            timeStamp = 1000000000;
+            for( Int_t recLoop = 0; recLoop < nrOfRecords; recLoop ++ )
+            {
+               if( randomTimeStamps )
+               timeStamp = (Int_t)(1200000000*(gRandom->Rndm()));
+               else
+               timeStamp += (Int_t)(50*(gRandom->Rndm()) );
+               if( 1000*(gRandom->Rndm()) > 50 ) 
+                  dcsVal = new AliDCSValue((Int_t)1, timeStamp);
+               else
+                  dcsVal = new AliDCSValue((Int_t)0, timeStamp);
+               valueSetStTL->Add(dcsVal);
+            } /*for( recLoop )*/
+            aliasMap->Add(new TObjString(aliasName), valueSetStTL);
+            created += nrOfRecords;
+
+            sprintf(dpName,"SDD_LAYER%i_LADDER%02d_MODULE%d_TEMP_R_STATE", iLay, iLad,iMod);
+            aliasName=dpName;
+            nrOfRecords = (Int_t)(maxRecords * ( gRandom->Rndm() ));
+            timeStamp = 1000000000;
+            for( Int_t recLoop = 0; recLoop < nrOfRecords; recLoop ++ )
+            {
+               if( randomTimeStamps )
+               timeStamp = (Int_t)(1200000000*(gRandom->Rndm()));
+               else
+               timeStamp += (Int_t)(50*(gRandom->Rndm()) );
+               if( 1000*(gRandom->Rndm()) > 50 ) 
+                  dcsVal = new AliDCSValue((Int_t)1, timeStamp);
+               else
+                  dcsVal = new AliDCSValue((Int_t)0, timeStamp);
+               valueSetStTR->Add(dcsVal);
+
+            } /*for( recLoop )*/
+            aliasMap->Add(new TObjString(aliasName), valueSetStTR);
+            created += nrOfRecords;
+
+         } /*for( iMod ) */
+      } /*for( iLad )*/
+
+  } /*for( iLay )*/
+
+  fprintf(  stderr, "\nCreated %i objects of type AliDCSValue ... \n", created);
+
+  return aliasMap;
+}
+
+// -----------------------------------------------------------------------------
+
+void GenerateOutputFiles( TMap *map, char *dir )
+{
+
+  FILE  *outputFile;
+  char   buffer[100],cmd[100];
+  Int_t  nHVEntries, nMVEntries, nTLEntries, nTREntries;
+  Int_t  nOKEntries, nStTLEntries, nStTREntries;
+  
+  sprintf(cmd,"ls -l %s >/dev/null 2>&1",dir);
+  if(gSystem->Exec(cmd)!=0){
+    printf("%s --- NOT EXISTS -- create it\n",dir);
+    sprintf(cmd,"mkdir %s",dir);
+    gSystem->Exec(cmd);
+  }
+
+  for( Int_t iLay = 3; iLay < 5; iLay++ )
+  {
+
+     Int_t maxLad = ( iLay == 3) ? kNladders3 : kNladders4;
+     Int_t maxMod = ( iLay == 3) ? kNmodLad3 : kNmodLad4;
+
+     for(Int_t iLad = 0; iLad < maxLad; iLad++)
+     {
+
+
+        for(Int_t iMod = 0; iMod < maxMod; iMod++)
+        {
+
+           sprintf( buffer, "%s/DCSMapContent_SDD_LAYER%i_LADDER%02d_MODULE%d.txt", dir, iLay, iLad, iMod );
+
+           fprintf( stderr, "Creating file %s ... ", buffer );
+           outputFile = fopen( buffer, "w" );
+            if( outputFile == NULL )
+            {
+               fprintf( stderr, "failed!\n" );
+               return;
+            } /*if*/
+            else
+             fprintf( stderr, "\n" );
+
+
+           sprintf( buffer, "SDD_LAYER%i_LADDER%02d_MODULE%d_HV", iLay, iLad, iMod );
+           TObjArray* arrHV = (TObjArray*) map->GetValue( buffer );
+           if( arrHV == NULL ) 
+           {
+               fprintf( stderr, "Map record %s does not exist!\n", buffer );
+               nHVEntries = 0;
+           }
+           else
+            nHVEntries = arrHV->GetEntries();
+
+           sprintf( buffer, "SDD_LAYER%i_LADDER%02d_MODULE%d_MV", iLay, iLad, iMod );
+           TObjArray* arrMV = (TObjArray*) map->GetValue( buffer );
+           if( arrMV == NULL ) 
+           {
+               fprintf( stderr, "Map record %s does not exist!\n", buffer );
+               nMVEntries = 0;
+           }
+           else
+            nMVEntries = arrMV->GetEntries();
+
+           sprintf( buffer, "SDD_LAYER%i_LADDER%02d_MODULE%d_TEMP_L", iLay, iLad, iMod );
+           TObjArray* arrTL = (TObjArray*) map->GetValue( buffer );
+           if( arrTL == NULL ) 
+           {
+               fprintf( stderr, "Map record %s does not exist!\n", buffer );
+               nTLEntries = 0;
+           }
+           else
+            nTLEntries = arrTL->GetEntries();
+
+           sprintf( buffer, "SDD_LAYER%i_LADDER%02d_MODULE%d_TEMP_R", iLay, iLad, iMod );
+           TObjArray* arrTR = (TObjArray*) map->GetValue( buffer );
+           if( arrTR == NULL ) 
+           {
+               fprintf( stderr, "Map record %s does not exist!\n", buffer );
+               nTREntries = 0;
+           }
+           else
+            nTREntries = arrTR->GetEntries();
+
+           sprintf( buffer, "SDD_LAYER%i_LADDER%02d_MODULE%d_TEMP_L_STATE", iLay, iLad, iMod );
+           TObjArray* arrStTL = (TObjArray*) map->GetValue( buffer );
+           if( arrStTL == NULL ) 
+           {
+               fprintf( stderr, "Map record %s does not exist!\n", buffer );
+               nStTLEntries = 0;
+           }
+           else
+            nStTLEntries = arrStTL->GetEntries();
+
+           sprintf( buffer, "SDD_LAYER%i_LADDER%02d_MODULE%d_TEMP_R_STATE", iLay, iLad, iMod );
+           TObjArray* arrStTR = (TObjArray*) map->GetValue( buffer );
+           if( arrStTR == NULL ) 
+           {
+               fprintf( stderr, "Map record %s does not exist!\n", buffer );
+               nStTREntries = 0;
+           }
+           else
+            nStTREntries = arrStTR->GetEntries();
+
+           sprintf( buffer, "SDD_LAYER%i_LADDER%02d_MODULE%d_OK", iLay, iLad, iMod );
+           TObjArray* arrOK = (TObjArray*) map->GetValue( buffer );
+           if( arrOK == NULL ) 
+           {
+               fprintf( stderr, "Map record %s does not exist!\n", buffer );
+               nOKEntries = 0;
+           }
+           else
+            nOKEntries = arrOK->GetEntries();
+
+           fprintf( outputFile, "+-----------------------------------------------------------------------");
+           fprintf( outputFile, "------------------------------------------------------------------------+\n" );
+           fprintf( outputFile, "|                                                DCS Map content for SDD_LAYER%i_LADDER%02d_MODULE%d" , iLay, iLad, iMod); 
+           fprintf( outputFile, "                                                |\n" );
+           fprintf( outputFile, "+----------------------+----------------------+---------------------+----------------------+");
+           fprintf( outputFile, "-----------------+-----------------+----------------+\n" );
+           fprintf( outputFile, "|    %05i  records    |    %05i  records    |    %05i  records   |    %05i  records   |  %05i records  |",
+                                 nHVEntries, nMVEntries, nTLEntries, nTREntries, nStTLEntries );
+           fprintf( outputFile, "  %05i records  | %05i  records  |\n", nStTREntries, nOKEntries );
+
+           fprintf( outputFile, "|  time (s)     HV     |  time (s)      MV    |  time (s)     TL    |  time (s)     TR    | time (s)   StTL |" );
+           fprintf( outputFile, " time (s)   StTR | time (s)   OK   |\n" );
+           fprintf( outputFile, "+----------------------+----------------------+---------------------+---------------------+");
+           fprintf( outputFile, "-----------------+-----------------+-----------------+\n" );
+
+
+
+           Int_t a = (nHVEntries > nMVEntries ) ? nHVEntries : nMVEntries;
+           Int_t b = (nTLEntries > nTREntries ) ? nTLEntries : nTREntries;
+           Int_t c = (nStTLEntries > nStTREntries ) ? nStTLEntries : nStTREntries;
+           if( a < b ) a = b; if( c < nOKEntries ) c = nOKEntries;
+           Int_t loopMax = ( a > c ) ? a : c ;
+                        // Finds maximal entry number
+
+
+
+           for( Int_t entryLoop = 0; entryLoop < loopMax; entryLoop++ )
+           {
+
+               if( entryLoop < nHVEntries )
+                fprintf( outputFile, "| %12i %4.2f | ", ((AliDCSValue*)arrHV->At(entryLoop))->GetTimeStamp(),
+                                                                   ((AliDCSValue*)arrHV->At(entryLoop))->GetFloat() );
+               else
+                fprintf( outputFile, "|                      | ");
+
+               if( entryLoop < nMVEntries )
+               fprintf( outputFile, " %12i  %2.2f | ", ((AliDCSValue*)arrMV->At(entryLoop))->GetTimeStamp(), 
+                                                                   ((AliDCSValue*)arrMV->At(entryLoop))->GetFloat() );
+               else
+               fprintf( outputFile, "                     | ");
+
+               if( entryLoop < nTLEntries )
+               fprintf( outputFile, "%12i  %2.2f | ", ((AliDCSValue*)arrTL->At(entryLoop))->GetTimeStamp(), 
+                                                                   ((AliDCSValue*)arrTL->At(entryLoop))->GetFloat() );
+               else
+               fprintf( outputFile, "                    | ");
+
+               if( entryLoop < nTREntries )
+               fprintf( outputFile, "%12i  %2.2f | ", ((AliDCSValue*)arrTR->At(entryLoop))->GetTimeStamp(), 
+                                                                   ((AliDCSValue*)arrTR->At(entryLoop))->GetFloat() );
+               else
+               fprintf( outputFile, "                    | ");
+
+               if( entryLoop < nStTLEntries )
+               fprintf( outputFile, "%12i  %i | ", ((AliDCSValue*)arrStTL->At(entryLoop))->GetTimeStamp(),
+                                                                   ((AliDCSValue*)arrStTL->At(entryLoop))->GetInt() );
+               else
+               fprintf( outputFile, "                | ");
+
+               if( entryLoop < nStTREntries )
+               fprintf( outputFile, "%12i  %i | ",  ((AliDCSValue*)arrStTR->At(entryLoop))->GetTimeStamp(),
+                                                                   ((AliDCSValue*)arrStTR->At(entryLoop))->GetInt() );
+               else
+               fprintf( outputFile, "                | ");
+
+               if( entryLoop < nOKEntries )
+               fprintf( outputFile, "%12i  %i |\n",  ((AliDCSValue*)arrOK->At(entryLoop))->GetTimeStamp(), 
+                                                                    ((AliDCSValue*)arrOK->At(entryLoop))->GetBool() );
+               else
+               fprintf( outputFile, "                |\n");
+
+           } /*for( entryLoop )*/
+
+           fclose( outputFile );
+
+
+        } /*for(iMod)*/
+
+
+     } /*for(iLad)*/
+   } /*for(iLay)*/
+
+
+} /*GenerateOutputFiles*/