Coding conventions
authorcblume <cblume@f7af4fe6-9843-0410-8265-dc069ae4e863>
Wed, 20 Jun 2007 12:36:23 +0000 (12:36 +0000)
committercblume <cblume@f7af4fe6-9843-0410-8265-dc069ae4e863>
Wed, 20 Jun 2007 12:36:23 +0000 (12:36 +0000)
TRD/AliTRDDataDCS.cxx
TRD/AliTRDDataDCS.h
TRD/TRDbaseLinkDef.h

index 094bdb5..427434e 100644 (file)
 //                                                                        //
 // This class collects the DCS information and does an AliSplineFit       //
 //                                                                        //
+// Typical use :                                                          //
+//                                                                        //
+//   AliTRDDataDCS dataDcs;                                               //
+//   dataDcs.ExtractDCS(dcs);                                             //
+//   ->call a storeRef function                                           //
+//   dataDcs.PerformFit();                                                //                        
+//   dataDcs.ClearGraphs();                                               //
+//   ->call a store function                                              //
+//   dataDcs.ClearFits();                                                 //
+//                                                                        //
 // Author:                                                                //
 //   W. Monange   (wilfried.monange@free.fr)                              //
 //                                                                        //
 ////////////////////////////////////////////////////////////////////////////
 
-
 #include <TGraph.h>
 #include <TObjArray.h>
 #include <AliCDBMetaData.h>
 
 ClassImp(AliTRDDataDCS)
 
-/*
-Typical use :
-
-AliTRDDataDCS dataDcs;
-dataDcs.ExtractDCS (dcs);
-->call a storeRef function
-dataDcs.PerformFit ();
-dataDcs.ClearGraphs ();
-->call a store function
-dataDcs.ClearFits ();
-
-*/
-
 //_____________________________________________________________________________
-AliTRDDataDCS::AliTRDDataDCS () 
-  :  chamberByteStatus         (0),
-     preTrigger                (1),
-     goofyHv           (2),
-     goofyPeakPos      (3),
-     goofyPeakArea     (4),
-     goofyTemp                 (5),
-     goofyPressure     (6),
-     goofyVelocity     (7),
-     goofyGain                 (8),
-     goofyCO2          (9),
-     goofyN2           (10),
-     gasO2             (11),
-     gasOverpressure   (12),
-     envTemp           (13),
-     hvAnodeImon       (14),
-     hvDriftImon       (15),
-     hvAnodeUmon       (16),
-     hvDriftUmon       (17),
-     adcClkPhase       (18),
-     atmPressure       (19),
-     luminosity        (20),
-     magneticField     (21),
-     fNAlias           (22),
-     graphsAreIni      (false),
-     fitsAreIni        (false)
+AliTRDDataDCS::AliTRDDataDCS() 
+  :TNamed()       
+  ,fGraphsAreIni(kFALSE)
+  ,fFitsAreIni(kFALSE)
+  ,fNAlias(22)
 {
+  //
+  // Default constructor
+  //
+
   Init ();
+
 }
 
 //_____________________________________________________________________________
-AliTRDDataDCS::~AliTRDDataDCS ()
+AliTRDDataDCS::~AliTRDDataDCS()
 {
-  ClearFits ();
-  ClearGraphs ();
+  //
+  // Destructor
+  //
+
+  ClearFits();
+  ClearGraphs();
+
 }
 
 //_____________________________________________________________________________
-void AliTRDDataDCS::Init ()
+void AliTRDDataDCS::Init()
 {
-  SetConf (chamberByteStatus, "trd_chamberByteStatus%03d", 'c', 540, true, false, 10,10,0,2); 
-  SetConf (preTrigger,                 "trd_preTrigger",               'c', 1, true, true,     10,10,0,2);
-  SetConf (goofyHv,                    "trd_goofyHv",                  'f', 1, true, true,     10,10,0,2);
-  SetConf (goofyPeakPos,               "trd_goofyPeakPos%02d", 'f', 2, true, true,     10,10,0,2);
-  SetConf (goofyPeakArea,      "trd_goofyPeakArea%02d",'f', 2, true, true,     10,10,0,2);
-  SetConf (goofyTemp,          "trd_goofyTemp%02d",    'f', 2, true, true,     10,10,0,2);
-  SetConf (goofyPressure,      "trd_goofyPressure",    'f', 1, true, true,     10,10,0,2);
-  SetConf (goofyVelocity,      "trd_goofyVelocity",    'f', 1, true, true,     10,10,0,2);
-  SetConf (goofyGain,          "trd_goofyGain%02d",    'f', 2, true, true,     10,10,0,2);
-  SetConf (goofyCO2,                   "trd_goofyCO2",                 'f', 1, true, true,     10,10,0,2);
-  SetConf (goofyN2,                    "trd_goofyN2",                  'f', 1, true, true,     10,10,0,2);
-  SetConf (gasO2,                      "trd_gasO2",                    'f', 1, true, true,     10,10,0,2);
-  SetConf (gasOverpressure,    "trd_gasOverpressure",  'f', 1, true, true,     10,10,0,2);
-  SetConf (envTemp,                    "trd_envTemp%03d",              'f', 540, true, true,   10,10,0,2);
-  SetConf (hvAnodeImon,                "trd_hvAnodeImon%03d",  'f', 540, true, true,   10,10,0,2);
-  SetConf (hvDriftImon,                "trd_hvDriftImon%03d",  'f', 540, true, true,   10,10,0,2);
-  SetConf (hvAnodeUmon,                "trd_hvAnodeUmon%03d",  'f', 540, true, true,   10,10,0,2);
-  SetConf (hvDriftUmon,                "trd_hvDriftUmon%03d",  'f', 540, true, true,   10,10,0,2);
-  SetConf (adcClkPhase,                "trd_adcClkPhase",              'f', 1, true, true,     10,10,0,2);
-  SetConf (atmPressure,                "trd_atmPressure",              'f', 1, true, true,     10,10,0,2);
-  SetConf (luminosity,                 "trd_luminosity",               'f', 1, true, true,     10,10,0,2);
-  SetConf (magneticField,      "trd_magneticField",    'f', 1, true, true,     10,10,0,2);             
+  //
+  // Initialization
+  //
+
+  SetConf(kChamberByteStatus, "trd_chamberByteStatus%03d",'c', 540, kTRUE,kFALSE,       10,10,0,2); 
+  SetConf(kPreTrigger,               "trd_preTrigger",           'c',   1, kTRUE, kTRUE,       10,10,0,2);
+  SetConf(kGoofyHv,          "trd_goofyHv",              'f',   1, kTRUE, kTRUE,       10,10,0,2);
+  SetConf(kGoofyPeakPos,      "trd_goofyPeakPos%02d",     'f',   2, kTRUE, kTRUE,      10,10,0,2);
+  SetConf(kGoofyPeakArea,     "trd_goofyPeakArea%02d",    'f',   2, kTRUE, kTRUE,      10,10,0,2);
+  SetConf(kGoofyTemp,        "trd_goofyTemp%02d",        'f',   2, kTRUE, kTRUE,       10,10,0,2);
+  SetConf(kGoofyPressure,     "trd_goofyPressure",       'f',   1, kTRUE, kTRUE,       10,10,0,2);
+  SetConf(kGoofyVelocity,     "trd_goofyVelocity",       'f',   1, kTRUE, kTRUE,       10,10,0,2);
+  SetConf(kGoofyGain,        "trd_goofyGain%02d",        'f',   2, kTRUE, kTRUE,       10,10,0,2);
+  SetConf(kGoofyCO2,         "trd_goofyCO2",             'f',   1, kTRUE, kTRUE,       10,10,0,2);
+  SetConf(kGoofyN2,          "trd_goofyN2",              'f',   1, kTRUE, kTRUE,       10,10,0,2);
+  SetConf(kGasO2,            "trd_gasO2",                'f',   1, kTRUE, kTRUE,       10,10,0,2);
+  SetConf(kGasOverpressure,   "trd_gasOverpressure",     'f',   1, kTRUE, kTRUE,       10,10,0,2);
+  SetConf(kEnvTemp,          "trd_envTemp%03d",          'f', 540, kTRUE, kTRUE,       10,10,0,2);
+  SetConf(kHvAnodeImon,       "trd_hvAnodeImon%03d",             'f', 540, kTRUE, kTRUE,       10,10,0,2);
+  SetConf(kHvDriftImon,       "trd_hvDriftImon%03d",     'f', 540, kTRUE, kTRUE,       10,10,0,2);
+  SetConf(kHvAnodeUmon,       "trd_hvAnodeUmon%03d",     'f', 540, kTRUE, kTRUE,       10,10,0,2);
+  SetConf(kHvDriftUmon,       "trd_hvDriftUmon%03d",     'f', 540, kTRUE, kTRUE,       10,10,0,2);
+  SetConf(kAdcClkPhase,       "trd_adcClkPhase",         'f',   1, kTRUE, kTRUE,       10,10,0,2);
+  SetConf(kAtmPressure,       "trd_atmPressure",         'f',   1, kTRUE, kTRUE,       10,10,0,2);
+  SetConf(kLuminosity,               "trd_luminosity",           'f',   1, kTRUE, kTRUE,       10,10,0,2);
+  SetConf(kMagneticField,     "trd_magneticField",       'f',   1, kTRUE, kTRUE,       10,10,0,2);             
   
   for (UInt_t iAlias = 0; iAlias < fNAlias; iAlias++) {
-    fDatas[iAlias].graph.SetOwner (1);
-    fDatas[iAlias].fit.SetOwner (1);
+    fDatas[iAlias].GetGraph().SetOwner(1);
+    fDatas[iAlias].GetFit().SetOwner(1);
   }
+
 }
 
 //_____________________________________________________________________________
-void AliTRDDataDCS::SetConf (UInt_t iAlias, const char * amanda, 
+void AliTRDDataDCS::SetConf(UInt_t iAlias, const char *amanda, 
                             char dataType, UInt_t nChannel, 
-                            Bool_t enableGraph, Bool_t enableFit, Int_t kMinPoints, 
-                            Int_t kIter, Double_t kMaxDelta, Int_t kFitReq)
+                            Bool_t enableGraph, Bool_t enableFit, Int_t minPoints, 
+                            Int_t iter, Double_t maxDelta, Int_t fitReq)
 {
+  //
+  // Configure a DCS alias
+  //
+
   if (iAlias >= fNAlias) {
     AliWarning (Form("Alias %d is not correct", iAlias));
     return;
   }
   
-  fConfs[iAlias].amanda = amanda;
-  fConfs[iAlias].dataType = dataType;
-  fConfs[iAlias].nChannel = nChannel;
-  fConfs[iAlias].enableGraph = enableGraph;
-  fConfs[iAlias].enableFit = enableFit;
-  fConfs[iAlias].kMinPoints = kMinPoints;
-  fConfs[iAlias].kIter = kIter;
-  fConfs[iAlias].kMaxDelta = kMaxDelta;
-  fConfs[iAlias].kFitReq = kFitReq;
+  fConfs[iAlias].SetAmanda(amanda);
+  fConfs[iAlias].SetDataType(dataType);
+  fConfs[iAlias].SetNChannel(nChannel);
+  fConfs[iAlias].SetEnableGraph(enableGraph);
+  fConfs[iAlias].SetEnableFit(enableFit);
+  fConfs[iAlias].SetMinPoints(minPoints);
+  fConfs[iAlias].SetIter(iter);
+  fConfs[iAlias].SetMaxDelta(maxDelta);
+  fConfs[iAlias].SetFitReq(fitReq);
   
 }
 
 //_____________________________________________________________________________
-void AliTRDDataDCS::InitFits ()
+void AliTRDDataDCS::InitFits()
 {
-  if (fitsAreIni)
+  //
+  // Initialize the fits
+  //
+
+  if (fFitsAreIni)
     return;
   
   UInt_t nChannel;
   for (UInt_t iAlias = 0; iAlias < fNAlias; iAlias++) {
-    nChannel = fConfs[iAlias].enableFit ? fConfs[iAlias].nChannel : 0;
-    fDatas[iAlias].fit.Expand (nChannel);      
+    nChannel = fConfs[iAlias].GetEnableFit() ? fConfs[iAlias].GetNChannel() : 0;
+    fDatas[iAlias].GetFit().Expand(nChannel);  
   }
   
-  fitsAreIni = true;
+  fFitsAreIni = kTRUE;
 }
 
 //_____________________________________________________________________________
-void AliTRDDataDCS::InitGraphs ()
+void AliTRDDataDCS::InitGraphs()
 {
-  if (graphsAreIni)
+  //
+  // Initialize the graphs
+  //
+
+  if (fGraphsAreIni)
     return;
   
   UInt_t nChannel;     
   for (UInt_t iAlias = 0; iAlias < fNAlias; iAlias++) {
-    nChannel = fConfs[iAlias].enableGraph ? fConfs[iAlias].nChannel : 0;        
-    fDatas[iAlias].graph.Expand (nChannel);
+    nChannel = fConfs[iAlias].GetEnableGraph() ? fConfs[iAlias].GetNChannel() : 0;      
+    fDatas[iAlias].GetGraph().Expand(nChannel);
   }
   
-  graphsAreIni = true;
+  fGraphsAreIni = kTRUE;
 }
 
 //_____________________________________________________________________________
-void AliTRDDataDCS::ClearFits ()
+void AliTRDDataDCS::ClearFits()
 {
+  //
+  // Clear the fits
+  //
+
   for (UInt_t iAlias = 0; iAlias < fNAlias; iAlias++) {
-    fDatas[iAlias].fit.Clear ();
-    fDatas[iAlias].fit.Expand (0);
+    fDatas[iAlias].GetFit().Clear();
+    fDatas[iAlias].GetFit().Expand(0);
   }
   
-  fitsAreIni = false;
+  fFitsAreIni = kFALSE;
 }
 
 //_____________________________________________________________________________
-void AliTRDDataDCS::ClearGraphs ()
-{      
+void AliTRDDataDCS::ClearGraphs()
+{
+  //
+  // Clear the grpahs
+  //
+
   for (UInt_t iAlias = 0; iAlias < fNAlias; iAlias++) {
-    fDatas[iAlias].graph.Clear ();
-    fDatas[iAlias].graph.Expand (0);
+    fDatas[iAlias].GetGraph().Clear();
+    fDatas[iAlias].GetGraph().Expand(0);
   }
   
-  graphsAreIni = false;
+  fGraphsAreIni = kFALSE;
 }
 
-//_____________________________________________________________________________
-void AliTRDDataDCS::Streamer(TBuffer &R__b) {
-  
-  if (R__b.IsReading()) {
+// //_____________________________________________________________________________
+// void AliTRDDataDCS::Streamer(TBuffer &R__b) 
+// {
+//   //
+//   // Custom streamer
+//   //
+  
+//   if (R__b.IsReading()) {
     
-    R__b.ReadBool (graphsAreIni);
-    R__b.ReadBool (fitsAreIni);
+//     R__b.ReadBool (fGraphsAreIni);
+//     R__b.ReadBool (fFitsAreIni);
     
     
-    for (UInt_t iAlias=0; iAlias<fNAlias; iAlias++) {
-      TString::ReadString (R__b, TString::Class());
-      R__b.ReadChar (fConfs[iAlias].dataType);
-      R__b.ReadUInt (fConfs[iAlias].nChannel);
-      R__b.ReadBool (fConfs[iAlias].enableGraph);
-      R__b.ReadBool (fConfs[iAlias].enableFit);
-      R__b.ReadInt  (fConfs[iAlias].kMinPoints);
-      R__b.ReadInt  (fConfs[iAlias].kIter);
-      R__b.ReadDouble  (fConfs[iAlias].kMaxDelta);
-      R__b.ReadInt  (fConfs[iAlias].kFitReq);
-    }
+//     for (UInt_t iAlias=0; iAlias<fNAlias; iAlias++) {
+//       TString::ReadString (R__b, TString::Class());
+//       R__b.ReadChar (fConfs[iAlias].fDataType);
+//       R__b.ReadUInt (fConfs[iAlias].fNChannel);
+//       R__b.ReadBool (fConfs[iAlias].fEnableGraph);
+//       R__b.ReadBool (fConfs[iAlias].fEnableFit);
+//       R__b.ReadInt  (fConfs[iAlias].fMinPoints);
+//       R__b.ReadInt  (fConfs[iAlias].fIter);
+//       R__b.ReadDouble  (fConfs[iAlias].fMaxDelta);
+//       R__b.ReadInt  (fConfs[iAlias].fFitReq);
+//     }
     
     
-    if (graphsAreIni) {
-      for (UInt_t iAlias=0; iAlias<fNAlias; iAlias++)
-       fDatas[iAlias].graph = *(TObjArray*)R__b.ReadObject (TObjArray::Class());
-    }
+//     if (fGraphsAreIni) {
+//       for (UInt_t iAlias=0; iAlias<fNAlias; iAlias++)
+//     fDatas[iAlias].GetGraph() = *(TObjArray*)R__b.ReadObject (TObjArray::Class());
+//     }
     
-    if (fitsAreIni) {
-      for (UInt_t iAlias=0; iAlias<fNAlias; iAlias++)
-       fDatas[iAlias].fit = *(TObjArray*)R__b.ReadObject (TObjArray::Class());
-    }
+//     if (fFitsAreIni) {
+//       for (UInt_t iAlias=0; iAlias<fNAlias; iAlias++)
+//     fDatas[iAlias].GetFit() = *(TObjArray*)R__b.ReadObject (TObjArray::Class());
+//     }
     
-    AliInfo (Form("Read %d octets to the stream (%d Ko)", R__b.Length(), R__b.Length()/1024));
+//     AliInfo (Form("Read %d octets to the stream (%d Ko)", R__b.Length(), R__b.Length()/1024));
     
-  } else {
-    R__b.WriteBool (graphsAreIni);
-    R__b.WriteBool (fitsAreIni);
+//   } else {
+//     R__b.WriteBool (fGraphsAreIni);
+//     R__b.WriteBool (fFitsAreIni);
     
-    for (UInt_t iAlias = 0; iAlias < fNAlias; iAlias++) {
-      TString::WriteString (R__b, &fConfs[iAlias].amanda);
-      R__b.WriteChar (fConfs[iAlias].dataType);
-      R__b.WriteUInt (fConfs[iAlias].nChannel);
-      R__b.WriteBool (fConfs[iAlias].enableGraph);
-      R__b.WriteBool (fConfs[iAlias].enableFit);
-      R__b.WriteInt  (fConfs[iAlias].kMinPoints);
-      R__b.WriteInt  (fConfs[iAlias].kIter);
-      R__b.WriteDouble  (fConfs[iAlias].kMaxDelta);
-      R__b.WriteInt  (fConfs[iAlias].kFitReq);
-    }
+//     for (UInt_t iAlias = 0; iAlias < fNAlias; iAlias++) {
+//       TString::WriteString (R__b, &fConfs[iAlias].fAmanda);
+//       R__b.WriteChar (fConfs[iAlias].fDataType);
+//       R__b.WriteUInt (fConfs[iAlias].fNChannel);
+//       R__b.WriteBool (fConfs[iAlias].fEnableGraph);
+//       R__b.WriteBool (fConfs[iAlias].fEnableFit);
+//       R__b.WriteInt  (fConfs[iAlias].fMinPoints);
+//       R__b.WriteInt  (fConfs[iAlias].fIter);
+//       R__b.WriteDouble  (fConfs[iAlias].fMaxDelta);
+//       R__b.WriteInt  (fConfs[iAlias].fFitReq);
+//     }
     
-    if (graphsAreIni) {
-      for (UInt_t iAlias = 0; iAlias < fNAlias; iAlias++) 
-       R__b.WriteObject ((TObject*)&fDatas[iAlias].graph);
-    }
+//     if (fGraphsAreIni) {
+//       for (UInt_t iAlias = 0; iAlias < fNAlias; iAlias++) 
+//     R__b.WriteObject ((TObject*)&fDatas[iAlias].GetGraph());
+//     }
     
-    if (fitsAreIni) {
-      for (UInt_t iAlias = 0; iAlias < fNAlias; iAlias++) 
-       R__b.WriteObject ((TObject*)&fDatas[iAlias].fit);
-    }
+//     if (fFitsAreIni) {
+//       for (UInt_t iAlias = 0; iAlias < fNAlias; iAlias++) 
+//     R__b.WriteObject ((TObject*)&fDatas[iAlias].GetFit());
+//     }
     
-    AliInfo (Form("Write %d octets to the stream (%d Ko)", R__b.Length(), R__b.Length()/1024));
-  }
-}
+//     AliInfo (Form("Write %d octets to the stream (%d Ko)", R__b.Length(), R__b.Length()/1024));
+//   }
+// }
 
 //_____________________________________________________________________________
-Bool_t AliTRDDataDCS::ExtractDCS (TMap * dcsAlias)
+Bool_t AliTRDDataDCS::ExtractDCS (TMap *dcsAlias)
 {
+  //
+  // Extract the DCS information
+  //
+
   if (dcsAlias == 0x0) {
     AliWarning ("No DCS Map");
     return kFALSE;
   }
   
-  ClearGraphs ();
-  InitGraphs ();
+  ClearGraphs();
+  InitGraphs();
   
-  TGraph * graphTemp;
+  TGraph *graphTemp;
   UInt_t nChannel;
   
   for (UInt_t iAlias = 0; iAlias < fNAlias; iAlias++){
     
     // extract dcs only when it is needed
-    nChannel = fDatas[iAlias].graph.GetSize ();
+    nChannel = fDatas[iAlias].GetGraph().GetSize();
     
     for (UInt_t iSensor=0; iSensor < nChannel; iSensor++) {
       
-      graphTemp = FindAndMakeGraph (dcsAlias, 
-                                   Form (fConfs[iAlias].amanda.Data(), iSensor), 
-                                   fConfs[iAlias].dataType); 
+      graphTemp = FindAndMakeGraph(dcsAlias, 
+                                  Form(fConfs[iAlias].GetAmanda().Data(), iSensor), 
+                                  fConfs[iAlias].GetDataType()); 
       
-      fDatas[iAlias].graph.AddAt (graphTemp, iSensor);
+      fDatas[iAlias].GetGraph().AddAt(graphTemp, iSensor);
     }
   }
   
@@ -293,18 +311,22 @@ Bool_t AliTRDDataDCS::ExtractDCS (TMap * dcsAlias)
 }
 
 //_____________________________________________________________________________
-TGraph * AliTRDDataDCS::FindAndMakeGraph (TMap * dcsMap, const char * amandaStr, 
+TGraph *AliTRDDataDCS::FindAndMakeGraph (TMap *dcsMap, const char *amandaStr, 
                                          char dataType)
 {
-  TGraph * graph;
+  //
+  // Create the graphs
+  //
+
+  TGraph *graph;
   
-  TPair * pair = (TPair*)dcsMap->FindObject(amandaStr);
+  TPair *pair = (TPair *) dcsMap->FindObject(amandaStr);
   if (pair == 0x0) {
     AliWarning (Form("Can't find %s in dcsMap", amandaStr));
     return 0x0;
   }
   
-  TObjArray * valueSet = (TObjArray*)pair->Value();
+  TObjArray *valueSet = (TObjArray *) pair->Value();
   
   //
   // Make graph of values read from DCS map
@@ -317,19 +339,19 @@ TGraph * AliTRDDataDCS::FindAndMakeGraph (TMap * dcsMap, const char * amandaStr,
     return 0x0;
   }
   
-  Float_t * x = new Float_t [nEntries];
-  Float_t * y = new Float_t [nEntries];
+  Float_t * x = new Float_t[nEntries];
+  Float_t * y = new Float_t[nEntries];
   
-  Bool_t ok = true;
+  Bool_t ok = kTRUE;
   Int_t time0 = 0;
   Int_t iEntries;
   for (iEntries = 0;  iEntries< nEntries; iEntries++) {
     
-    AliDCSValue * val = (AliDCSValue *)valueSet->At(iEntries);
+    AliDCSValue *val = (AliDCSValue *) valueSet->At(iEntries);
     
     if (val == 0x0) { 
       ok = false;
-      AliError (Form("Entry %s at %d contain no datas", amandaStr, iEntries));
+      AliError(Form("Entry %s at %d contain no datas", amandaStr, iEntries));
       break;
     }
     
@@ -350,13 +372,13 @@ TGraph * AliTRDDataDCS::FindAndMakeGraph (TMap * dcsMap, const char * amandaStr,
       
     default :
       ok = false;
-      AliError (Form("Bad type for entry %s", amandaStr));
+      AliError(Form("Bad type for entry %s", amandaStr));
       break;
     }
   }
   
   if (ok)
-    graph = new TGraph (iEntries, x, y);
+    graph = new TGraph(iEntries, x, y);
   else
     graph = 0x0;
   
@@ -366,34 +388,37 @@ TGraph * AliTRDDataDCS::FindAndMakeGraph (TMap * dcsMap, const char * amandaStr,
   return graph;
 }
 
-
 //_____________________________________________________________________________
-Bool_t AliTRDDataDCS::PerformFit ()
+Bool_t AliTRDDataDCS::PerformFit()
 {
-  AliSplineFit * fitTemp;
+  //
+  // Do the fit
+  //
+
+  AliSplineFit *fitTemp;
   
-  ClearFits ();
-  InitFits ();
+  ClearFits();
+  InitFits();
   
   UInt_t nChannel;
   
   for (UInt_t iAlias = 0; iAlias < fNAlias; iAlias++){
     
     // perform fit only when it is needed
-    nChannel = fDatas[iAlias].fit.GetSize ();
+    nChannel = fDatas[iAlias].GetFit().GetSize();
     
     for (UInt_t iSensor=0; iSensor < nChannel; iSensor++) {
       
-      fitTemp = Fit ((TGraph*)fDatas[iAlias].graph[iSensor],
-                    fConfs[iAlias].kMinPoints,
-                    fConfs[iAlias].kIter,
-                    fConfs[iAlias].kMaxDelta,
-                    fConfs[iAlias].kFitReq); 
+      fitTemp = Fit((TGraph*)fDatas[iAlias].GetGraph(iSensor),
+                    fConfs[iAlias].GetMinPoints(),
+                    fConfs[iAlias].GetIter(),
+                    fConfs[iAlias].GetMaxDelta(),
+                    fConfs[iAlias].GetFitReq()); 
       
       if (fitTemp == 0x0)
-       AliInfo (Form ("Can't fit %s", Form (fConfs[iAlias].amanda.Data(), iSensor)));
+       AliInfo(Form("Can't fit %s", Form(fConfs[iAlias].GetAmanda().Data(), iSensor)));
       
-      fDatas[iAlias].fit.AddAt (fitTemp, iSensor);
+      fDatas[iAlias].GetFit().AddAt(fitTemp, iSensor);
     }
   }
   
@@ -402,101 +427,121 @@ Bool_t AliTRDDataDCS::PerformFit ()
 }
 
 //_____________________________________________________________________________
-AliSplineFit * AliTRDDataDCS::Fit (TGraph * graph, 
-                                  Int_t  kMinPoints, Int_t  kIter, 
-                                  Double_t  kMaxDelta, Int_t  kFitReq)
+AliSplineFit *AliTRDDataDCS::Fit(TGraph *graph, 
+                                Int_t  minPoints, Int_t  iter, 
+                                Double_t  maxDelta, Int_t  fitReq)
 {
   if (graph == 0x0) {
-    AliError ("No graph for fit");
+    AliError("No graph for fit");
     return 0x0;
   }
   
-  AliSplineFit * spline = new AliSplineFit ();
-  spline->InitKnots (new TGraph (*graph), kMinPoints, kIter, kMaxDelta);
-  spline->SplineFit (kFitReq);
+  AliSplineFit *spline = new AliSplineFit();
+  spline->InitKnots(new TGraph (*graph), minPoints, iter, maxDelta);
+  spline->SplineFit(fitReq);
   spline->Cleanup();   // delete also new TGraph (*graph)
   
   return spline;
 }
 
-
 //_____________________________________________________________________________
-void AliTRDDataDCS::Print (Option_t* option) const
+void AliTRDDataDCS::Print(Option_t* option) const
 {
+  //
+  // Print function
+  //
+
   if (option[0]=='g' || option[0]=='\0'){
     
-    if (graphsAreIni){
+    if (fGraphsAreIni){
       
       for (UInt_t iAlias = 0; iAlias < fNAlias; iAlias++){
        
-       for (Int_t iSensor = 0; iSensor < fDatas[iAlias].graph.GetSize(); iSensor++) {
+       for (Int_t iSensor = 0; iSensor < fDatas[iAlias].GetGraph().GetSize(); iSensor++) {
          
-         if (fDatas[iAlias].graph[iSensor] != 0x0)
-           AliInfo (Form("Graph %s contain %d point(s)", 
-                         Form(fConfs[iAlias].amanda, iSensor), 
-                         ((TGraph*)(fDatas[iAlias].graph[iSensor]))->GetN ()));
+         if (fDatas[iAlias].GetGraph(iSensor) != 0x0)
+           AliInfo(Form("Graph %s contain %d point(s)", 
+                         Form(fConfs[iAlias].GetAmanda(), iSensor), 
+                         ((TGraph*)(fDatas[iAlias].GetGraph(iSensor)))->GetN()));
        }
       }
-    }else{
-      AliInfo ("Graphs don't exist");
+    }
+    else{
+      AliInfo("Graphs don't exist");
     }
   }
   
   
   if (option[0] == 'f' || option[0]=='\0'){
     
-    AliInfo ("no print for fit");
+    AliInfo("no print for fit");
     
   }
   
 }
 
 //_____________________________________________________________________________
-TGraph * AliTRDDataDCS::GetGraph (UInt_t iAlias, UInt_t iChannel) const
+TGraph *AliTRDDataDCS::GetGraph(UInt_t iAlias, UInt_t iChannel) const
 {
+  //
+  // Get a graph
+  //
+
   if (iAlias >= fNAlias) {
-    AliWarning (Form("Alias %d is not correct", iAlias));
+    AliWarning(Form("Alias %d is not correct", iAlias));
     return 0x0;
   }
   
-  if (iChannel >= (UInt_t)fDatas[iAlias].graph.GetSize()) {
-    AliWarning (Form("Alias %s is not correct", 
-                    Form(fConfs[iAlias].amanda.Data(), iChannel)));
+  if (iChannel >= (UInt_t) fDatas[iAlias].GetGraph().GetSize()) {
+    AliWarning(Form("Alias %s is not correct", 
+                    Form(fConfs[iAlias].GetAmanda().Data(), iChannel)));
     return 0x0;
   }
   
-  return (TGraph *)fDatas[iAlias].graph[iChannel];
+  return (TGraph *)fDatas[iAlias].GetGraph(iChannel);
 }
 
 //_____________________________________________________________________________
-AliSplineFit * AliTRDDataDCS::GetFit (UInt_t iAlias, UInt_t iChannel) const
+AliSplineFit *AliTRDDataDCS::GetFit(UInt_t iAlias, UInt_t iChannel) const
 {
+  //
+  // Get the spline fit
+  //
+
   if (iAlias >= fNAlias) {
     AliWarning (Form("Alias %d is not correct", iAlias));
     return 0x0;
   }
   
-  if (iChannel >= (UInt_t)fDatas[iAlias].fit.GetSize()) {
-    AliWarning (Form("Alias %s is not correct", 
-                    Form(fConfs[iAlias].amanda.Data(), iChannel)));
+  if (iChannel >= (UInt_t) fDatas[iAlias].GetFit().GetSize()) {
+    AliWarning(Form("Alias %s is not correct", 
+                    Form(fConfs[iAlias].GetAmanda().Data(), iChannel)));
     return 0x0;
   }
   
-  return (AliSplineFit *)fDatas[iAlias].fit[iChannel];
+  return (AliSplineFit *) fDatas[iAlias].GetFit(iChannel);
 }
 
 //_____________________________________________________________________________
 TString AliTRDDataDCS::GetAmandaStr (UInt_t iAlias) const 
 {
+  //
+  // Return the AMANDA string
+  //
+
   if (iAlias < fNAlias)
-    return fConfs[iAlias].amanda;
+    return fConfs[iAlias].GetAmanda();
   else return TString ();
 }
 
 //_____________________________________________________________________________
 UInt_t AliTRDDataDCS::GetNChannel (UInt_t iAlias) const 
 {
+  //
+  // Get the channel number
+  //
+
   if (iAlias < fNAlias)
-    return fConfs[iAlias].nChannel;
+    return fConfs[iAlias].GetNChannel();
   else return 0;
 }
index 3f5dc48..6f3b26d 100644 (file)
@@ -1,5 +1,5 @@
-#ifndef AliTRDDataDCS_H
-#define AliTRDDAtaDCS_H
+#ifndef AliTRDDATADCS_H
+#define AliTRDDATADCS_H
 
 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
  * See cxx source for full Copyright notice                               */
 ////////////////////////////////////////////////////////////////////////////
 
 #include <TNamed.h>
-#include <TObjArray.h>
-#include <TString.h>
+
+class TObjArray;
+class TString;
 
 class TGraph;
 class AliSplineFit;
 class TMap;
 
-
 class AliTRDDataDCS : public TNamed
 {
   
@@ -42,87 +42,56 @@ class AliTRDDataDCS : public TNamed
   AliSplineFit *       GetFit (UInt_t iAlias, UInt_t iChannel = 0) const;
   
   // Get TGraph
-  TGraph * GetGraphChamberByteStatus (UInt_t iSensor) const            {return GetGraph (chamberByteStatus, iSensor);}
-  TGraph * GetGraphPreTrigger () const                                         {return GetGraph (preTrigger);}
-  TGraph * GetGraphGoofyHv () const                                    {return GetGraph (goofyHv);}
-  TGraph * GetGraphGoofyPeakPos (UInt_t iSensor) const                 {return GetGraph (goofyPeakPos, iSensor);}
-  TGraph * GetGraphGoofyPeakArea (UInt_t iSensor) const                {return GetGraph (goofyPeakArea, iSensor);}
-  TGraph * GetGraphGoofyTemp (UInt_t iSensor) const                    {return GetGraph (goofyTemp, iSensor);}
-  TGraph * GetGraphGoofyPressure () const                              {return GetGraph (goofyPressure);}
-  TGraph * GetGraphGoofyVelocity () const                              {return GetGraph (goofyVelocity);}
-  TGraph * GetGraphGoofyGain (UInt_t iSensor) const                    {return GetGraph (goofyGain, iSensor);}
-  TGraph * GetGraphGoofyCO2 ()  const                                  {return GetGraph (goofyCO2);}
-  TGraph * GetGraphGoofyN2 () const                                    {return GetGraph (goofyN2);}
-  TGraph * GetGraphGasO2 () const                                      {return GetGraph (gasO2);}
-  TGraph * GetGraphGasOverpressure () const                            {return GetGraph (gasOverpressure);}
-  TGraph * GetGraphEnvTemp (UInt_t iSensor) const                      {return GetGraph (envTemp, iSensor);}
-  TGraph * GetGraphHvAnodeImon (UInt_t iSensor) const                  {return GetGraph (hvAnodeImon, iSensor);}
-  TGraph * GetGraphHvDriftImon (UInt_t iSensor) const                  {return GetGraph (hvDriftImon, iSensor);}
-  TGraph * GetGraphHvAnodeUmon (UInt_t iSensor) const                  {return GetGraph (hvAnodeUmon, iSensor);}
-  TGraph * GetGraphHvDriftUmon (UInt_t iSensor) const                  {return GetGraph (hvDriftUmon, iSensor);}
-  TGraph * GetGraphAdcClkPhase () const                                {return GetGraph (adcClkPhase);}
-  TGraph * GetGraphAtmPressure () const                                {return GetGraph (atmPressure);}
-  TGraph * GetGraphLuminosity () const                                         {return GetGraph (luminosity);}
-  TGraph * GetGraphMagneticField () const                              {return GetGraph (magneticField);}
+  TGraph * GetGraphChamberByteStatus (UInt_t iSensor) const            {return GetGraph (kChamberByteStatus, iSensor);}
+  TGraph * GetGraphPreTrigger () const                                         {return GetGraph (kPreTrigger);}
+  TGraph * GetGraphGoofyHv () const                                    {return GetGraph (kGoofyHv);}
+  TGraph * GetGraphGoofyPeakPos (UInt_t iSensor) const                 {return GetGraph (kGoofyPeakPos, iSensor);}
+  TGraph * GetGraphGoofyPeakArea (UInt_t iSensor) const                {return GetGraph (kGoofyPeakArea, iSensor);}
+  TGraph * GetGraphGoofyTemp (UInt_t iSensor) const                    {return GetGraph (kGoofyTemp, iSensor);}
+  TGraph * GetGraphGoofyPressure () const                              {return GetGraph (kGoofyPressure);}
+  TGraph * GetGraphGoofyVelocity () const                              {return GetGraph (kGoofyVelocity);}
+  TGraph * GetGraphGoofyGain (UInt_t iSensor) const                    {return GetGraph (kGoofyGain, iSensor);}
+  TGraph * GetGraphGoofyCO2 ()  const                                  {return GetGraph (kGoofyCO2);}
+  TGraph * GetGraphGoofyN2 () const                                    {return GetGraph (kGoofyN2);}
+  TGraph * GetGraphGasO2 () const                                      {return GetGraph (kGasO2);}
+  TGraph * GetGraphGasOverpressure () const                            {return GetGraph (kGasOverpressure);}
+  TGraph * GetGraphEnvTemp (UInt_t iSensor) const                      {return GetGraph (kEnvTemp, iSensor);}
+  TGraph * GetGraphHvAnodeImon (UInt_t iSensor) const                  {return GetGraph (kHvAnodeImon, iSensor);}
+  TGraph * GetGraphHvDriftImon (UInt_t iSensor) const                  {return GetGraph (kHvDriftImon, iSensor);}
+  TGraph * GetGraphHvAnodeUmon (UInt_t iSensor) const                  {return GetGraph (kHvAnodeUmon, iSensor);}
+  TGraph * GetGraphHvDriftUmon (UInt_t iSensor) const                  {return GetGraph (kHvDriftUmon, iSensor);}
+  TGraph * GetGraphAdcClkPhase () const                                {return GetGraph (kAdcClkPhase);}
+  TGraph * GetGraphAtmPressure () const                                {return GetGraph (kAtmPressure);}
+  TGraph * GetGraphLuminosity () const                                         {return GetGraph (kLuminosity);}
+  TGraph * GetGraphMagneticField () const                              {return GetGraph (kMagneticField);}
   
-  AliSplineFit * GetFitChamberByteStatus (UInt_t iSensor) const                {return GetFit (chamberByteStatus, iSensor);}
-  AliSplineFit * GetFitPreTrigger () const                             {return GetFit (preTrigger);}
-  AliSplineFit * GetFitGoofyHv () const                                        {return GetFit (goofyHv);}
-  AliSplineFit * GetFitGoofyPeakPos (UInt_t iSensor) const             {return GetFit (goofyPeakPos, iSensor);}
-  AliSplineFit * GetFitGoofyPeakArea (UInt_t iSensor) const            {return GetFit (goofyPeakArea, iSensor);}
-  AliSplineFit * GetFitGoofyTemp (UInt_t iSensor) const                        {return GetFit (goofyTemp, iSensor);}
-  AliSplineFit * GetFitGoofyPressure () const                          {return GetFit (goofyPressure);}
-  AliSplineFit * GetFitGoofyVelocity () const                          {return GetFit (goofyVelocity);}
-  AliSplineFit * GetFitGoofyGain (UInt_t iSensor) const                        {return GetFit (goofyGain, iSensor);}
-  AliSplineFit * GetFitGoofyCO2 ()  const                              {return GetFit (goofyCO2);}
-  AliSplineFit * GetFitGoofyN2 () const                                {return GetFit (goofyN2);}
-  AliSplineFit * GetFitGasO2 () const                                  {return GetFit (gasO2);}
-  AliSplineFit * GetFitGasOverpressure () const                        {return GetFit (gasOverpressure);}
-  AliSplineFit * GetFitEnvTemp (UInt_t iSensor) const                  {return GetFit (envTemp, iSensor);}
-  AliSplineFit * GetFitHvAnodeImon (UInt_t iSensor) const              {return GetFit (hvAnodeImon, iSensor);}
-  AliSplineFit * GetFitHvDriftImon (UInt_t iSensor) const              {return GetFit (hvDriftImon, iSensor);}
-  AliSplineFit * GetFitHvAnodeUmon (UInt_t iSensor) const              {return GetFit (hvAnodeUmon, iSensor);}
-  AliSplineFit * GetFitHvDriftUmon (UInt_t iSensor) const              {return GetFit (hvDriftUmon, iSensor);}
-  AliSplineFit * GetFitAdcClkPhase () const                            {return GetFit (adcClkPhase);}
-  AliSplineFit * GetFitAtmPressure () const                            {return GetFit (atmPressure);}
-  AliSplineFit * GetFitLuminosity () const                             {return GetFit (luminosity);}
-  AliSplineFit * GetFitMagneticField () const                          {return GetFit (magneticField);}
+  AliSplineFit * GetFitChamberByteStatus (UInt_t iSensor) const                {return GetFit (kChamberByteStatus, iSensor);}
+  AliSplineFit * GetFitPreTrigger () const                             {return GetFit (kPreTrigger);}
+  AliSplineFit * GetFitGoofyHv () const                                        {return GetFit (kGoofyHv);}
+  AliSplineFit * GetFitGoofyPeakPos (UInt_t iSensor) const             {return GetFit (kGoofyPeakPos, iSensor);}
+  AliSplineFit * GetFitGoofyPeakArea (UInt_t iSensor) const            {return GetFit (kGoofyPeakArea, iSensor);}
+  AliSplineFit * GetFitGoofyTemp (UInt_t iSensor) const                        {return GetFit (kGoofyTemp, iSensor);}
+  AliSplineFit * GetFitGoofyPressure () const                          {return GetFit (kGoofyPressure);}
+  AliSplineFit * GetFitGoofyVelocity () const                          {return GetFit (kGoofyVelocity);}
+  AliSplineFit * GetFitGoofyGain (UInt_t iSensor) const                        {return GetFit (kGoofyGain, iSensor);}
+  AliSplineFit * GetFitGoofyCO2 ()  const                              {return GetFit (kGoofyCO2);}
+  AliSplineFit * GetFitGoofyN2 () const                                {return GetFit (kGoofyN2);}
+  AliSplineFit * GetFitGasO2 () const                                  {return GetFit (kGasO2);}
+  AliSplineFit * GetFitGasOverpressure () const                        {return GetFit (kGasOverpressure);}
+  AliSplineFit * GetFitEnvTemp (UInt_t iSensor) const                  {return GetFit (kEnvTemp, iSensor);}
+  AliSplineFit * GetFitHvAnodeImon (UInt_t iSensor) const              {return GetFit (kHvAnodeImon, iSensor);}
+  AliSplineFit * GetFitHvDriftImon (UInt_t iSensor) const              {return GetFit (kHvDriftImon, iSensor);}
+  AliSplineFit * GetFitHvAnodeUmon (UInt_t iSensor) const              {return GetFit (kHvAnodeUmon, iSensor);}
+  AliSplineFit * GetFitHvDriftUmon (UInt_t iSensor) const              {return GetFit (kHvDriftUmon, iSensor);}
+  AliSplineFit * GetFitAdcClkPhase () const                            {return GetFit (kAdcClkPhase);}
+  AliSplineFit * GetFitAtmPressure () const                            {return GetFit (kAtmPressure);}
+  AliSplineFit * GetFitLuminosity () const                             {return GetFit (kLuminosity);}
+  AliSplineFit * GetFitMagneticField () const                          {return GetFit (kMagneticField);}
   
   void Print (Option_t* option = "") const;
-  
-  
-  public :
-    
-    const UInt_t  chamberByteStatus;
-    const UInt_t  preTrigger;
-    const UInt_t  goofyHv;
-    const UInt_t  goofyPeakPos;
-    const UInt_t  goofyPeakArea;
-    const UInt_t  goofyTemp;
-    const UInt_t  goofyPressure;
-    const UInt_t  goofyVelocity;
-    const UInt_t  goofyGain;
-    const UInt_t  goofyCO2;
-    const UInt_t  goofyN2;
-    const UInt_t  gasO2;
-    const UInt_t  gasOverpressure;
-    const UInt_t  envTemp ;
-    const UInt_t  hvAnodeImon;
-    const UInt_t  hvDriftImon;
-    const UInt_t  hvAnodeUmon;
-    const UInt_t  hvDriftUmon;
-    const UInt_t  adcClkPhase;
-    const UInt_t  atmPressure;
-    const UInt_t  luminosity;
-    const UInt_t  magneticField;
-    const UInt_t  fNAlias;
-    
-    
     
-    protected :
-      
-      private :
-      
+  protected :
+          
       TGraph * FindAndMakeGraph (TMap * dcsMap, const char * amandaStr,
                                 char dataType);
     AliSplineFit * Fit (TGraph * graph,
@@ -137,33 +106,99 @@ class AliTRDDataDCS : public TNamed
                  Bool_t enableGraph, Bool_t enableFit, Int_t kMinPoints, 
                  Int_t kIter, Double_t kMaxDelta, Int_t kFitReq);
     
-    private :
-      
-      Bool_t graphsAreIni;
-      Bool_t fitsAreIni;
-      
-      struct data {
-       TObjArray fit;                  // array of AliSplineFit
-       TObjArray graph;                // array of TGraph
-      };
-      
-      struct conf {
-       TString amanda;                 // amanda string
-       char dataType;                  // 'c' for char, 'f' for float
-       UInt_t nChannel;                // number of channel
-       Bool_t enableGraph;             // will be converted in TGraph
-       Bool_t enableFit;               // will be converted in AliSplineFit
-       Int_t  kMinPoints;              // minimum number of points per knot in fit
-       Int_t  kIter;                   // number of iterations for spline fit
-       Double_t  kMaxDelta;            // precision parameter for spline fit
-       Int_t  kFitReq;                 // fit requirement, 2 = continuous 2nd derivative
-      };
+  private :
+    
+    enum { kChamberByteStatus = 0
+         , kPreTrigger        = 1
+         , kGoofyHv           = 2
+         , kGoofyPeakPos      = 3
+         , kGoofyPeakArea     = 4
+         , kGoofyTemp         = 5
+         , kGoofyPressure     = 6
+         , kGoofyVelocity     = 7
+         , kGoofyGain         = 8
+         , kGoofyCO2          = 9
+         , kGoofyN2           = 10
+         , kGasO2             = 11
+         , kGasOverpressure   = 12
+         , kEnvTemp           = 13
+         , kHvAnodeImon       = 14
+         , kHvDriftImon       = 15
+         , kHvAnodeUmon       = 16
+         , kHvDriftUmon       = 17
+         , kAdcClkPhase       = 18
+         , kAtmPressure       = 19
+         , kLuminosity        = 20
+         , kMagneticField     = 21
+    };
+              
+    Bool_t fGraphsAreIni;
+    Bool_t fFitsAreIni;
+    UInt_t fNAlias;
       
-      data fDatas [22];                
-      conf fConfs [22];                        
+    class AliTRDDataDCSdata {
+     public:
+      AliTRDDataDCSdata()
+       :fFit(0x0)
+        ,fGraph(0x0) { };
+      virtual ~AliTRDDataDCSdata() { };
+      TObjArray GetFit() const          { return fFit;      }
+      TObjArray GetGraph() const        { return fGraph;    }
+      TObject*  GetFit(Int_t i) const   { return fFit[i];   }
+      TObject*  GetGraph(Int_t i) const { return fGraph[i]; }
+     protected:
+      TObjArray fFit;                  // array of AliSplineFit
+      TObjArray fGraph;                        // array of TGraph
+    };      
+
+    class AliTRDDataDCSconf {
+     public:
+      AliTRDDataDCSconf()
+       :fAmanda(0)
+       ,fDataType(0)
+       ,fNChannel(0)
+       ,fEnableGraph(0)
+       ,fEnableFit(0)
+       ,fMinPoints(0)
+       ,fIter(0)
+       ,fMaxDelta(0)
+       ,fFitReq(0) { };
+      virtual ~AliTRDDataDCSconf() { };
+      TString  GetAmanda() const        { return fAmanda;      }
+      Char_t   GetDataType() const      { return fDataType;    }
+      UInt_t   GetNChannel() const      { return fNChannel;    }
+      Bool_t   GetEnableGraph() const   { return fEnableGraph; }
+      Bool_t   GetEnableFit() const     { return fEnableFit;   }
+      Int_t    GetMinPoints() const     { return fMinPoints;   }
+      Int_t    GetIter() const          { return fIter;        }
+      Double_t GetMaxDelta() const      { return fMaxDelta;    }
+      Int_t    GetFitReq() const        { return fFitReq;      }
+      void     SetAmanda(TString s)     { fAmanda      = s;    }
+      void     SetDataType(Char_t d)    { fDataType    = d;    }
+      void     SetNChannel(UInt_t n)    { fNChannel    = n;    }
+      void     SetEnableGraph(Bool_t e) { fEnableGraph = e;    }
+      void     SetEnableFit(Bool_t e)   { fEnableFit   = e;    }
+      void     SetMinPoints(Int_t m)    { fMinPoints   = m;    }
+      void     SetIter(Int_t i)         { fIter        = i;    }
+      void     SetMaxDelta(Double_t m)  { fMaxDelta    = m;    }
+      void     SetFitReq(Int_t f)       { fFitReq      = f;    }
+     protected:
+        TString   fAmanda;             // amanda string
+        Char_t    fDataType;           // 'c' for char, 'f' for float
+        UInt_t    fNChannel;           // number of channel
+        Bool_t    fEnableGraph;                // will be converted in TGraph
+        Bool_t    fEnableFit;          // will be converted in AliSplineFit
+        Int_t     fMinPoints;          // minimum number of points per knot in fit
+        Int_t     fIter;               // number of iterations for spline fit
+        Double_t  fMaxDelta;           // precision parameter for spline fit
+        Int_t     fFitReq;             // fit requirement, 2 = continuous 2nd derivative
+      };      
+
+      AliTRDDataDCSdata fDatas [22];   // configurations       
+      AliTRDDataDCSconf fConfs [22];   // data arrays          
       
-      ClassDef(AliTRDDataDCS,1)         //  TRD calibration class
+      ClassDef(AliTRDDataDCS,1)         // TRD calibration class
        
-       };
+};
 
 #endif
index c803052..66c4a4a 100644 (file)
@@ -49,7 +49,7 @@
 #pragma link C++ class  AliTRDCalibraMode+;
 #pragma link C++ class  AliTRDCalibraVector+;
 #pragma link C++ class  AliTRDCalibPadStatus+;
-#pragma link C++ class  AliTRDDataDCS-;
+#pragma link C++ class  AliTRDDataDCS+;
 #pragma link C++ class  AliTRDPreprocessor+;
 
 #pragma link C++ class  AliTRDTriggerL1+;