Time-related parameters needed in reconstruction moved from Trigger to Calib
authorcheynis <cheynis@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 5 Nov 2009 08:10:03 +0000 (08:10 +0000)
committercheynis <cheynis@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 5 Nov 2009 08:10:03 +0000 (08:10 +0000)
15 files changed:
VZERO/AliVZEROCalibData.cxx
VZERO/AliVZEROCalibData.h
VZERO/AliVZERODataDCS.cxx
VZERO/AliVZERODataDCS.h
VZERO/AliVZERODataFEE.cxx
VZERO/AliVZERODataFEE.h
VZERO/AliVZEROPreprocessor.cxx
VZERO/AliVZEROReconstructor.cxx
VZERO/AliVZEROReconstructor.h
VZERO/AliVZEROTriggerData.cxx
VZERO/AliVZEROTriggerData.h
VZERO/DBStorageCalib.C
VZERO/DBStorageFEE.C
VZERO/DCSValues.txt
VZERO/VZEROTestPreprocessor.C

index be76d17..3da8319 100644 (file)
 /////////////////////////////////////////////////////////////////////////////
 
 #include <TMath.h>
+#include <TObjString.h>
+#include <TMap.h>
 
+#include "AliDCSValue.h"
 #include "AliVZEROCalibData.h"
 
 ClassImp(AliVZEROCalibData)
@@ -31,6 +34,11 @@ ClassImp(AliVZEROCalibData)
 AliVZEROCalibData::AliVZEROCalibData()
 {
   // 
+       for(int i=0; i<kNCIUBoards ;i++) {
+               fTimeResolution[i] = 25./256.; // Default time resolution
+               fWidthResolution[i] = 25./64.;     // Default time width resolution
+       }
+
 }
 
 //________________________________________________________________
@@ -46,6 +54,10 @@ AliVZEROCalibData::AliVZEROCalibData(const char* name)
   namst += name;
   SetName(namst.Data());
   SetTitle(namst.Data());
+  for(int i=0; i<kNCIUBoards ;i++) {
+       fTimeResolution[i] = 25./256.; // Default time resolution in ns / channel
+       fWidthResolution[i] = 25./64.;     // Default time width resolution in ns / channel
+  }
 
 }
 
@@ -69,7 +81,15 @@ AliVZEROCalibData::AliVZEROCalibData(const AliVZEROCalibData& calibda) :
       fMeanHV[t]       = calibda.GetMeanHV(t);
       fWidthHV[t]      = calibda.GetWidthHV(t);        
       fTimeOffset[t]   = calibda.GetTimeOffset(t);
-      fTimeGain[t]     = calibda.GetTimeGain(t); }  
+      fTimeGain[t]     = calibda.GetTimeGain(t); 
+         fDeadChannel[t]  = calibda.IsChannelDead(t);
+  }  
+  
+       for(int i=0; i<kNCIUBoards ;i++) {
+               fTimeResolution[i]  = calibda.GetTimeResolution(i);
+               fWidthResolution[i] = calibda.GetWidthResolution(i);      
+       }
+
   
 }
 
@@ -92,7 +112,13 @@ AliVZEROCalibData &AliVZEROCalibData::operator =(const AliVZEROCalibData& calibd
       fMeanHV[t]       = calibda.GetMeanHV(t);
       fWidthHV[t]      = calibda.GetWidthHV(t);        
       fTimeOffset[t]   = calibda.GetTimeOffset(t);
-      fTimeGain[t]     = calibda.GetTimeGain(t); }   
+      fTimeGain[t]     = calibda.GetTimeGain(t); 
+         fDeadChannel[t]  = calibda.IsChannelDead(t);
+  }   
+       for(int i=0; i<kNCIUBoards ;i++) {
+               fTimeResolution[i]  = calibda.GetTimeResolution(i);
+               fWidthResolution[i] = calibda.GetWidthResolution(i);      
+       }
    
   return *this;
   
@@ -103,6 +129,42 @@ AliVZEROCalibData::~AliVZEROCalibData()
 {
   // destructor
 }
+//_____________________________________________________________________________
+void AliVZEROCalibData::FillDCSData(AliVZERODataDCS * data){
+       // Set all parameters from the data get by the shuttle
+       TMap * params = data->GetFEEParameters();
+       TIter iter(params);     
+       TObjString* aliasName;
+       
+       while ((  aliasName = (TObjString*) iter.Next() ))  {
+               AliDCSValue* aValue = (AliDCSValue*) params->GetValue(aliasName);
+               Float_t val;
+               if(aValue) {
+                       val = aValue->GetFloat();
+                       //AliInfo(Form("%s : %f",aliasName->String().Data(), val));
+                       SetParameter(aliasName->String(),val);
+               }
+       }       
+       
+       SetMeanHV(data->GetMeanHV());
+       SetWidthHV(data->GetWidthHV());
+       SetDeadMap(data->GetDeadMap());
+
+}
+//_____________________________________________________________________________
+void AliVZEROCalibData::SetParameter(TString name, Float_t val){
+       // Set given parameter
+       
+       Int_t iBoard = -1;
+
+       TSeqCollection* nameSplit = name.Tokenize("/");
+       TObjString * boardName = (TObjString *)nameSplit->At(2);
+       sscanf(boardName->String().Data(),"CIU%d",&iBoard);
+               
+       if(name.Contains("TimeResolution")) SetTimeResolution((UShort_t) val,iBoard-1);
+       else if(name.Contains("WidthResolution")) SetWidthResolution((UShort_t) val,iBoard-1);
+       else AliError(Form("No Setter found for FEE parameter : %s",name.Data()));
+}
 
 //________________________________________________________________
 void AliVZEROCalibData::SetPedestal(Float_t* Pedestal)
@@ -207,4 +269,103 @@ Float_t AliVZEROCalibData::GetMIPperADC(Int_t channel) const {
        return MIP; 
        
 }
+//________________________________________________________________
+void AliVZEROCalibData::SetTimeResolution(UShort_t *resols){
+       // Set Time Resolution of the TDC
+       if(resols)  for(int t=0; t<kNCIUBoards; t++) SetTimeResolution(resols[t],t);
+       else AliFatal("Time Resolution not defined.");
+       
+}
+//________________________________________________________________
+void AliVZEROCalibData::SetTimeResolution(UShort_t resol, Int_t board)
+{
+       // Set Time Resolution of the TDC
+       if((board<kNCIUBoards)) {
+               switch(resol){
+                       case 0:
+                               fTimeResolution[board] = 25./256.;
+                               break;
+                       case 1:
+                               fTimeResolution[board] = 25./128.;
+                               break;
+                       case 2:
+                               fTimeResolution[board] = 25./64.;
+                               break;
+                       case 3:
+                               fTimeResolution[board] = 25./32.;
+                               break;
+                       case 4:
+                               fTimeResolution[board] = 25./16.;
+                               break;
+                       case 5:
+                               fTimeResolution[board] = 25./8.;
+                               break;
+                       case 6:
+                               fTimeResolution[board] = 6.25;
+                               break;
+                       case 7:
+                               fTimeResolution[board] = 12.5;
+                               break;
+               }
+       } else AliError(Form("Board %d is not valid",board));
+}
+//________________________________________________________________
+void AliVZEROCalibData::SetWidthResolution(UShort_t *resols){
+       // Set Time Width Resolution of the TDC
+       if(resols)  for(int t=0; t<kNCIUBoards; t++) SetWidthResolution(resols[t],t);
+       else AliFatal("Width Resolution not defined.");
+       
+}
+//________________________________________________________________
+void AliVZEROCalibData::SetWidthResolution(UShort_t resol, Int_t board)
+{
+       // Set Time Width Resolution of the TDC
+       if((board<kNCIUBoards)){
+               switch(resol){
+                       case 0:
+                               fWidthResolution[board] = 25./256.;
+                               break;
+                       case 1:
+                               fWidthResolution[board] = 25./128.;
+                               break;
+                       case 2:
+                               fWidthResolution[board] = 25./64.;
+                               break;
+                       case 3:
+                               fWidthResolution[board] = 25./32.;
+                               break;
+                       case 4:
+                               fWidthResolution[board] = 25./16.;
+                               break;
+                       case 5:
+                               fWidthResolution[board] = 25./8.;
+                               break;
+                       case 6:
+                               fWidthResolution[board] = 6.25;
+                               break;
+                       case 7:
+                               fWidthResolution[board] = 12.5;
+                               break;
+                       case 8:
+                               fWidthResolution[board] = 25.;
+                               break;
+                       case 9:
+                               fWidthResolution[board] = 50.;
+                               break;
+                       case 10:
+                               fWidthResolution[board] = 100.;
+                               break;
+                       case 11:
+                               fWidthResolution[board] = 200.;
+                               break;
+                       case 12:
+                               fWidthResolution[board] = 400.;
+                               break;
+                       case 13:
+                               fWidthResolution[board] = 800.;
+                               break;
+                               
+               }
+       }else AliError(Form("Board %d is not valid",board));
+}
 
index 7b3ff73..eb6d6a4 100644 (file)
 
 #include "TNamed.h"
 #include "AliVZERO.h"
+#include "AliVZERODataDCS.h"
 
 class AliVZEROCalibData: public TNamed {
 
  public:
+  enum { kNCIUBoards = 8 };
+  
   AliVZEROCalibData();
   AliVZEROCalibData(const char* name);
   AliVZEROCalibData(const AliVZEROCalibData &calibda);
   AliVZEROCalibData& operator= (const AliVZEROCalibData &calibda);
   virtual ~AliVZEROCalibData();
   void Reset();
+  void FillDCSData(AliVZERODataDCS * data);
 
   Float_t  GetPedestal(Int_t channel)   const {return fPedestal[channel];}
   Float_t* GetPedestal()   const {return (float*)fPedestal;}
@@ -44,6 +48,12 @@ class AliVZEROCalibData: public TNamed {
   Float_t* GetTimeOffset()   const {return (float*)fTimeOffset;}
   Float_t  GetTimeGain(Int_t channel)  const {return fTimeGain[channel];}
   Float_t* GetTimeGain()   const {return (float*)fTimeGain;}
+
+  Float_t* GetTimeResolution() const {return (Float_t*) fTimeResolution;};
+  Float_t  GetTimeResolution(Int_t board ) const  {return (board<kNCIUBoards?fTimeResolution[board]:0);};
+
+  Float_t* GetWidthResolution() const {return (Float_t*) fWidthResolution;};
+  Float_t  GetWidthResolution(Int_t board ) const  {return (board<kNCIUBoards?fWidthResolution[board]:0);};
     
   void     SetPedestal(Float_t val, Int_t channel) {fPedestal[channel]=val;}
   void     SetPedestal(Float_t* Pedestal);
@@ -66,6 +76,12 @@ class AliVZEROCalibData: public TNamed {
   void     SetTimeOffset(Float_t* TimeOffset);
   void     SetTimeGain(Float_t val, Int_t channel) {fTimeGain[channel]=val;}
   void     SetTimeGain(Float_t* TimeGain);
+  
+  void            SetParameter(TString name, Float_t val);
+  void     SetTimeResolution(UShort_t *resols);
+  void     SetTimeResolution(UShort_t resol, Int_t board);
+  void     SetWidthResolution(UShort_t *resols);
+  void     SetWidthResolution(UShort_t resol, Int_t board);
 
   Float_t  GetMIPperADC(Int_t channel) const;
 
@@ -81,6 +97,8 @@ class AliVZEROCalibData: public TNamed {
   Float_t  fTimeOffset[64];
   Float_t  fTimeGain[64];
   Bool_t   fDeadChannel[64];
+  Float_t  fTimeResolution[kNCIUBoards]; // Time Resolution of the TDC (ns / channel)
+  Float_t  fWidthResolution[kNCIUBoards]; // Time Width Resolution of the TDC (ns / channel)
 
   ClassDef(AliVZEROCalibData,3)    // VZERO Calibration data
 };
index a21d4eb..be18f1f 100644 (file)
@@ -25,6 +25,7 @@
 #include <TTimeStamp.h>
 #include <TMap.h>
 #include <TString.h>
+#include <TObjString.h>
 #include <TH1F.h>
 
 class TH2;
@@ -45,8 +46,10 @@ AliVZERODataDCS::AliVZERODataDCS():
        fRun(0),
        fStartTime(0),
        fEndTime(0),
-        fGraphs("TGraph",kNGraphs),
+    fGraphs("TGraph",kNGraphs),
+       fFEEParameters(NULL),
        fIsProcessed(kFALSE)
+
 {
   // Default constructor
   for(int i=0;i<kNHvChannel;i++) fDeadChannel[i] = kFALSE;
@@ -58,17 +61,20 @@ AliVZERODataDCS::AliVZERODataDCS(Int_t nRun, UInt_t startTime, UInt_t endTime):
        fRun(nRun),
        fStartTime(startTime),
        fEndTime(endTime),
-        fGraphs("TGraph",kNGraphs),
+       fGraphs("TGraph",kNGraphs),
+       fFEEParameters(new TMap()),
        fIsProcessed(kFALSE)
+
 {
 
   // constructor with arguments
        for(int i=0;i<kNHvChannel;i++) fDeadChannel[i] = kFALSE;
 
        AliInfo(Form("\n\tRun %d \n\tStartTime %s \n\tEndTime %s", nRun,
-       TTimeStamp(startTime).AsString(),
-       TTimeStamp(endTime).AsString()));
-
+               TTimeStamp(startTime).AsString(),
+               TTimeStamp(endTime).AsString()));
+       
+       fFEEParameters->SetOwnerValue();
        Init();
 
 }
@@ -78,6 +84,7 @@ AliVZERODataDCS::~AliVZERODataDCS() {
 
   // destructor
   fGraphs.Clear("C");
+  delete fFEEParameters;
 
 }
 
@@ -103,42 +110,47 @@ void AliVZERODataDCS::ProcessData(TMap& aliasMap){
     //Introduce(iAlias, aliasArr);
     
     if(aliasArr->GetEntries()<2){
-      AliError(Form("Alias %s has just %d entries!",
+      AliWarning(Form("Alias %s has just %d entries!",
                    fAliasNames[iAlias].Data(),aliasArr->GetEntries()));
-      continue;
     }
     
     TIter iterarray(aliasArr);
-    
-    Int_t nentries = aliasArr->GetEntries();
-    
-    Double_t *times = new Double_t[nentries];
-    Double_t *values = new Double_t[nentries];
-
-    UInt_t iValue=0;
-    Float_t variation = 0.0;
-    
-    while((aValue = (AliDCSValue*) iterarray.Next())) {
-               values[iValue] = aValue->GetFloat();
-               if(iValue>0) {
-                       if(values[iValue-1]>0.) variation = TMath::Abs(values[iValue]-values[iValue-1])/values[iValue-1];
-                       if(variation > 0.10) fDeadChannel[GetOfflineChannel(iAlias)] = kTRUE;
-               }
-               times[iValue] = (Double_t) (aValue->GetTimeStamp());
-               fHv[iAlias]->Fill(values[iValue]);
-               printf("%s %f Dead=%d\n",fAliasNames[iAlias].Data(),values[iValue],fDeadChannel[GetOfflineChannel(iAlias)]);
-               iValue++;
-    }      
-    CreateGraph(iAlias, aliasArr->GetEntries(), times, values); // fill graphs 
-    
-    delete[] values;
-    delete[] times;          
+       
+    if(iAlias<kNHvChannel){ // Treating HV values
+       Int_t nentries = aliasArr->GetEntries();
+
+       Double_t *times = new Double_t[nentries];
+       Double_t *values = new Double_t[nentries];
+
+       UInt_t iValue=0;
+       Float_t variation = 0.0;
+
+       while((aValue = (AliDCSValue*) iterarray.Next())) {
+                       values[iValue] = aValue->GetFloat();
+                       if(iValue>0) {
+                               if(values[iValue-1]>0.) variation = TMath::Abs(values[iValue]-values[iValue-1])/values[iValue-1];
+                               if(variation > 0.10) fDeadChannel[GetOfflineChannel(iAlias)] = kTRUE;
+                       }
+                       times[iValue] = (Double_t) (aValue->GetTimeStamp());
+                       fHv[iAlias]->Fill(values[iValue]);
+                       printf("%s %f Dead=%d\n",fAliasNames[iAlias].Data(),values[iValue],fDeadChannel[GetOfflineChannel(iAlias)]);
+                       iValue++;
+       }      
+       CreateGraph(iAlias, aliasArr->GetEntries(), times, values); // fill graphs 
+
+       delete[] values;
+       delete[] times; 
+       } else { // Treating FEE Parameters
+               AliDCSValue * lastVal = NULL;
+               while((aValue = (AliDCSValue*) iterarray.Next())) lastVal = aValue; // Take only the last value
+               fFEEParameters->Add(new TObjString(fAliasNames[iAlias].Data()),lastVal);
+       }      
   }
   
        // calculate mean and rms of the first two histos
        // and convert index to aliroot channel
-       for(int i=0;i<kNAliases;i++){
-               Int_t iChannel     = GetOfflineChannel(i);      
+       for(int i=0;i<kNHvChannel;i++){
+           Int_t iChannel     = GetOfflineChannel(i);  
                fMeanHV[iChannel]  = fHv[i]->GetMean();
                fWidthHV[iChannel] = fHv[i]->GetRMS();
        }
@@ -168,6 +180,14 @@ void AliVZERODataDCS::Init(){
                }
        }
   }
+
+ // Time Resolution Parameters
+       
+       for(int iCIU = 0; iCIU<8 ; iCIU++){
+               fAliasNames[iAlias++] = Form("V00/FEE/CIU%d/TimeResolution",iCIU);
+               fAliasNames[iAlias++] = Form("V00/FEE/CIU%d/WidthResolution",iCIU);
+       }
+
   if(iAlias!=kNAliases) 
              AliError(Form("Number of DCS Aliases defined not correct"));
 
index b0b2c3f..840d430 100644 (file)
@@ -20,7 +20,7 @@ class TH1F;
 
 class AliVZERODataDCS : public TObject {
 public:
-  enum {kNAliases=64,kNGraphs=64,kNHvChannel=64,kNLvChannel=16};
+  enum {kNAliases=80,kNGraphs=64,kNHvChannel=64,kNLvChannel=16,kNCIUBoards = 8};
   enum {kHvMin=0, kHvMax=2000};
   
   AliVZERODataDCS();
@@ -44,7 +44,8 @@ public:
   Float_t* GetMeanHV()    const {return (float*)fMeanHV;}
   Float_t* GetWidthHV()   const {return (float*)fWidthHV;}
   Bool_t * GetDeadMap()   const {return (bool*)fDeadChannel;}
-
+  TMap * GetFEEParameters() const {return fFEEParameters;};
+  
 // Getter of Offline Channel number as used in aliroot (defined by aliroot 
 // numbering convention) from DCS Channel number
 
@@ -78,10 +79,11 @@ private:
   Float_t fMeanHV[kNHvChannel];            // High Voltage mean values
   Float_t fWidthHV[kNHvChannel];           // High Voltage widths
   Bool_t  fDeadChannel[kNHvChannel];       // Dead Map 
-  
+  TMap * fFEEParameters;  // TMap holding the FEE parameters of Time Resolution
+    
   Bool_t fIsProcessed;                   // bool to know processing status
   
-  ClassDef(AliVZERODataDCS, 3);
+  ClassDef(AliVZERODataDCS, 4);
 };
 
 #endif
index 84f316a..ff3048e 100644 (file)
@@ -96,7 +96,7 @@ void AliVZERODataFEE::Init(){
        for(int iCIU = 0; iCIU<8 ; iCIU++){\r
                for(int iParam=0; iParam<kNCIUParam;iParam++){\r
                        fAliasNames[iAlias] = "V00/FEE/";\r
-                       fAliasNames[iAlias] += Form("CIU%d/",iCIU+1);\r
+                       fAliasNames[iAlias] += Form("CIU%d/",iCIU);\r
                        \r
                        fAliasNames[iAlias] += GetFEEParamName(iParam);\r
                        iAlias++;\r
@@ -104,7 +104,7 @@ void AliVZERODataFEE::Init(){
                for(int iParam=kNCIUParam; iParam<kNCIUParam+kNChannelParam;iParam++){\r
                        for(int iCh=1;iCh<=8;iCh++){\r
                                fAliasNames[iAlias] = "V00/FEE/";\r
-                               fAliasNames[iAlias] += Form("CIU%d/",iCIU+1);\r
+                               fAliasNames[iAlias] += Form("CIU%d/",iCIU);\r
                        \r
                                fAliasNames[iAlias] += GetFEEParamName(iParam);\r
                                fAliasNames[iAlias] += Form("%d",iCh);\r
@@ -147,7 +147,6 @@ void AliVZERODataFEE::ProcessData(TMap& aliasMap){
                AliDCSValue * lastVal = NULL;\r
                while((aValue = (AliDCSValue*) iterarray.Next())) lastVal = aValue; // Take only the last value\r
                \r
-               //AliInfo(Form("%s %f",fAliasNames[iAlias].Data(), val));\r
                fParameters->Add(new TObjString(fAliasNames[iAlias].Data()),lastVal);\r
                \r
        }\r
@@ -178,16 +177,14 @@ TString AliVZERODataFEE::GetFEEParamName(Int_t iParam){
                case 10: result = "ResetWin1"; break;\r
                case 11: result = "ResetWin2"; break;\r
                case 12: result = "PedestalSubtraction"; break;\r
-               case 13: result = "TimeResolution"; break;\r
-               case 14: result = "WidthResolution"; break;\r
-               case 15: result = "EnableCharge"; break;\r
-               case 16: result = "EnableTiming"; break;\r
-               case 17: result = "PedEven"; break;\r
-               case 18: result = "PedOdd"; break;\r
-               case 19: result = "PedCutEven"; break;\r
-               case 20: result = "PedCutOdd"; break;\r
-               case 21: result = "DelayHit"; break;\r
-               case 22: result = "DiscriThr"; break;\r
+               case 13: result = "EnableCharge"; break;\r
+               case 14: result = "EnableTiming"; break;\r
+               case 15: result = "PedEven"; break;\r
+               case 16: result = "PedOdd"; break;\r
+               case 17: result = "PedCutEven"; break;\r
+               case 18: result = "PedCutOdd"; break;\r
+               case 19: result = "DelayHit"; break;\r
+               case 20: result = "DiscriThr"; break;\r
        }\r
        return result;\r
 }\r
index 9467c12..44a7829 100644 (file)
@@ -38,7 +38,7 @@ public:
        \r
        TMap * GetParameters() const {return fParameters;};\r
        \r
-       enum { kNCIUBoards = 8, kNCIUParam = 15, kNChannelParam = 8, kNCCIUParam = 19, kNAliases  = kNChannelParam*8*kNCIUBoards +kNCIUParam*kNCIUBoards + kNCCIUParam };\r
+       enum { kNCIUBoards = 8, kNCIUParam = 13, kNChannelParam = 8, kNCCIUParam = 19, kNAliases  = kNChannelParam*8*kNCIUBoards +kNCIUParam*kNCIUBoards + kNCCIUParam };\r
 \r
 private:\r
        \r
index d18258f..f538c37 100644 (file)
@@ -97,15 +97,10 @@ UInt_t AliVZEROPreprocessor::Process(TMap* dcsAliasMap)
   if(!dcsAliasMap) return 1;
 
        // The Processing of the DCS input data is forwarded to AliVZERODataDCS
-
        fData->ProcessData(*dcsAliasMap);
-       //fData->Draw("");              // Draws the HV values as a function of time
-       //dcsAliasMap->Print("");       // Prints out the HV values
 
-       // Writes VZERO PMs HV values into VZERO calibration object
-       calibData->SetMeanHV(fData->GetMeanHV());
-       calibData->SetWidthHV(fData->GetWidthHV());
-       calibData->SetDeadMap(fData->GetDeadMap());
+       // Writes VZERO PMs HV values into VZERO calibration object and Timing resolution parameters
+       calibData->FillDCSData(fData);
           
    // *************** From DAQ ******************
    
index 0e57b4b..d1e4f6f 100644 (file)
@@ -35,7 +35,6 @@
 #include "AliESDVZEROfriend.h"
 #include "AliVZEROdigit.h"
 #include "AliVZEROCalibData.h"
-#include "AliVZEROTriggerData.h"
 
 ClassImp(AliVZEROReconstructor)
 
@@ -45,7 +44,6 @@ AliVZEROReconstructor:: AliVZEROReconstructor(): AliReconstructor(),
                         fESD(0x0),
                         fESDVZEROfriend(0x0),
                         fCalibData(GetCalibData()),
-                        fTriggerData(GetTriggerData()),
                         fCollisionMode(0),
                         fBeamEnergy(0.)
 {
@@ -122,8 +120,8 @@ void AliVZEROReconstructor::ConvertDigits(AliRawReader* rawReader, TTree* digits
         Int_t j       =  rawStream.GetOfflineChannel(i);
         Int_t board   = j / 8;
         adc[j]        =  ADC_max[i];
-        time[j]       =  rawStream.GetTime(i)/ (25./256.) * fTriggerData->GetTimeResolution(board);
-        width[j]      =  rawStream.GetWidth(i) / 0.4 * fTriggerData->GetWidthResolution(board);
+         time[j]       =  rawStream.GetTime(i)/ (25./256.) * fCalibData->GetTimeResolution(board);
+        width[j]      =  rawStream.GetWidth(i) / 0.4 * fCalibData->GetWidthResolution(board);
         BBFlag[j]     =  rawStream.GetBBFlag(i,imax);
         BGFlag[j]     =  rawStream.GetBGFlag(i,imax); 
         integrator[j] =  rawStream.GetIntegratorFlag(i,imax); 
@@ -378,32 +376,3 @@ AliVZEROCalibData* AliVZEROReconstructor::GetCalibData() const
   return calibdata;
 }
 
-//_____________________________________________________________________________
-AliVZEROTriggerData* AliVZEROReconstructor::GetTriggerData() const
-{
-  // Gets calibration object for VZERO set
-
-  AliCDBManager *man = AliCDBManager::Instance();
-
-  AliCDBEntry *entry=0;
-
-  entry = man->Get("VZERO/Trigger/Data");
-
-//   if(!entry){
-//     AliWarning("Load of calibration data from default storage failed!");
-//     AliWarning("Calibration data will be loaded from local storage ($ALICE_ROOT)");
-//     Int_t runNumber = man->GetRun();
-//     entry = man->GetStorage("local://$ALICE_ROOT/OCDB")
-//       ->Get("VZERO/Calib/Data",runNumber);
-//     
-//   }
-
-  // Retrieval of data in directory VZERO/Calib/Data:
-
-  AliVZEROTriggerData *triggerdata = 0;
-
-  if (entry) triggerdata = (AliVZEROTriggerData*) entry->GetObject();
-  if (!triggerdata)  AliFatal("No trigger data from calibration database !");
-
-  return triggerdata;
-}
index 59a03c9..242862b 100644 (file)
@@ -19,7 +19,6 @@
 #include "AliESDVZERO.h"
 
 class AliVZEROCalibData;
-class AliVZEROTriggerData;
 class AliESDEvent;
 class AliESDVZEROfriend;
 
@@ -49,7 +48,6 @@ public:
   void GetCollisionMode();
   
   AliVZEROCalibData *GetCalibData() const; 
-  AliVZEROTriggerData *GetTriggerData() const; 
 
   enum {kInvalidADC   =  -1024,
         kInvalidTime  =  -1};
@@ -64,12 +62,11 @@ private:
   AliVZEROReconstructor& operator = (const AliVZEROReconstructor& reconstructor);
   
   AliVZEROCalibData* fCalibData;      //! calibration data
-  AliVZEROTriggerData* fTriggerData;      //! FEE parameters
 
   Int_t              fCollisionMode;  // =0->p-p, =1->A-A
   Float_t            fBeamEnergy;     // beam energy
     
-  ClassDef(AliVZEROReconstructor, 0)  // class for the VZERO reconstruction
+  ClassDef(AliVZEROReconstructor, 1)  // class for the VZERO reconstruction
 };
 
 #endif
index a3b9ad0..c9004a7 100644 (file)
@@ -62,8 +62,6 @@ AliVZEROTriggerData::AliVZEROTriggerData() :
                fLatchWin1[i] = fLatchWin2[i] = 0;\r
                fResetWin1[i] = fResetWin2[i] = 0;\r
                fPedestalSubtraction[i] = kFALSE;\r
-               fTimeResolution[i] = 25./256.; // Default time resolution\r
-               fWidthResolution[i] = 0.4;     // Default time width resolution\r
        }\r
 }\r
 //________________________________________________________________\r
@@ -97,10 +95,8 @@ AliVZEROTriggerData::AliVZEROTriggerData(Int_t nRun, UInt_t startTime, UInt_t en
                fLatchWin1[i] = fLatchWin2[i] = 0;\r
                fResetWin1[i] = fResetWin2[i] = 0;\r
                fPedestalSubtraction[i] = kFALSE;\r
-               fTimeResolution[i] = 25./256.; // Default time resolution\r
-               fWidthResolution[i] = 0.4;     // Default time width resolution\r
        }\r
-       TString namst = "Trigger_FEE";\r
+       TString namst = "VZERO_Trigger_FEE";\r
        SetName(namst.Data());\r
        SetTitle(namst.Data());\r
        \r
@@ -157,8 +153,6 @@ void AliVZEROTriggerData::SetParameter(TString name, Float_t val){
        else if(name.Contains("ResetWin1")) SetResetWin1((UShort_t) val,iBoard-1);\r
        else if(name.Contains("ResetWin2")) SetResetWin2((UShort_t) val,iBoard-1);\r
        else if(name.Contains("PedestalSubtraction")) SetPedestalSubtraction((Bool_t) val,iBoard-1);\r
-       else if(name.Contains("TimeResolution")) SetTimeResolution((UShort_t) val,iBoard-1);\r
-       else if(name.Contains("WidthResolution")) SetWidthResolution((UShort_t) val,iBoard-1);\r
        else if(name.Contains("BBAThreshold")) SetBBAThreshold((UShort_t) val);\r
        else if(name.Contains("BBCThreshold")) SetBBCThreshold((UShort_t) val);\r
        else if(name.Contains("BGAThreshold")) SetBGAThreshold((UShort_t) val);\r
@@ -484,105 +478,6 @@ void AliVZEROTriggerData::SetPedestalSubtraction(Bool_t ped, Int_t board)
        if((board<kNCIUBoards)) fPedestalSubtraction[board] = ped;\r
        else AliError(Form("Board %d is not valid",board));\r
 }\r
-//________________________________________________________________\r
-void AliVZEROTriggerData::SetTimeResolution(UShort_t *resols){\r
-       // Set Time Resolution of the TDC\r
-       if(resols)  for(int t=0; t<kNCIUBoards; t++) SetTimeResolution(resols[t],t);\r
-       else AliFatal("Time Resolution not defined.");\r
-       \r
-}\r
-//________________________________________________________________\r
-void AliVZEROTriggerData::SetTimeResolution(UShort_t resol, Int_t board)\r
-{\r
-       // Set Time Resolution of the TDC\r
-       if((board<kNCIUBoards)) {\r
-               switch(resol){\r
-                       case 0:\r
-                               fTimeResolution[board] = 25./256.;\r
-                               break;\r
-                       case 1:\r
-                               fTimeResolution[board] = 25./128.;\r
-                               break;\r
-                       case 2:\r
-                               fTimeResolution[board] = 25./64.;\r
-                               break;\r
-                       case 3:\r
-                               fTimeResolution[board] = 25./32.;\r
-                               break;\r
-                       case 4:\r
-                               fTimeResolution[board] = 25./16.;\r
-                               break;\r
-                       case 5:\r
-                               fTimeResolution[board] = 25./8.;\r
-                               break;\r
-                       case 6:\r
-                               fTimeResolution[board] = 6.25;\r
-                               break;\r
-                       case 7:\r
-                               fTimeResolution[board] = 12.5;\r
-                               break;\r
-               }\r
-       } else AliError(Form("Board %d is not valid",board));\r
-}\r
-//________________________________________________________________\r
-void AliVZEROTriggerData::SetWidthResolution(UShort_t *resols){\r
-       // Set Time Width Resolution of the TDC\r
-       if(resols)  for(int t=0; t<kNCIUBoards; t++) SetWidthResolution(resols[t],t);\r
-       else AliFatal("Width Resolution not defined.");\r
-       \r
-}\r
-//________________________________________________________________\r
-void AliVZEROTriggerData::SetWidthResolution(UShort_t resol, Int_t board)\r
-{\r
-       // Set Time Width Resolution of the TDC\r
-       if((board<kNCIUBoards)){\r
-               switch(resol){\r
-                       case 0:\r
-                               fWidthResolution[board] = 25./256.;\r
-                               break;\r
-                       case 1:\r
-                               fWidthResolution[board] = 25./128.;\r
-                               break;\r
-                       case 2:\r
-                               fWidthResolution[board] = 25./64.;\r
-                               break;\r
-                       case 3:\r
-                               fWidthResolution[board] = 25./32.;\r
-                               break;\r
-                       case 4:\r
-                               fWidthResolution[board] = 25./16.;\r
-                               break;\r
-                       case 5:\r
-                               fWidthResolution[board] = 25./8.;\r
-                               break;\r
-                       case 6:\r
-                               fWidthResolution[board] = 6.25;\r
-                               break;\r
-                       case 7:\r
-                               fWidthResolution[board] = 12.5;\r
-                               break;\r
-                       case 8:\r
-                               fWidthResolution[board] = 25.;\r
-                               break;\r
-                       case 9:\r
-                               fWidthResolution[board] = 50.;\r
-                               break;\r
-                       case 10:\r
-                               fWidthResolution[board] = 100.;\r
-                               break;\r
-                       case 11:\r
-                               fWidthResolution[board] = 200.;\r
-                               break;\r
-                       case 12:\r
-                               fWidthResolution[board] = 400.;\r
-                               break;\r
-                       case 13:\r
-                               fWidthResolution[board] = 800.;\r
-                               break;\r
-                               \r
-               }\r
-       }else AliError(Form("Board %d is not valid",board));\r
-}\r
 \r
 //________________________________________________________________\r
 Bool_t AliVZEROTriggerData::IsClkValid(UShort_t clock) const {\r
index 29d0cc9..1ceb7c9 100644 (file)
@@ -61,12 +61,6 @@ public:
        void SetPedestalSubtraction(Bool_t *peds);\r
        void SetPedestalSubtraction(Bool_t ped, Int_t board);\r
        \r
-       void SetTimeResolution(UShort_t *resols);\r
-       void SetTimeResolution(UShort_t resol, Int_t board);\r
-       \r
-       void SetWidthResolution(UShort_t *resols);\r
-       void SetWidthResolution(UShort_t resol, Int_t board);\r
-               \r
        void SetBBAThreshold(UShort_t th) {fBBAThreshold = th;};\r
        void SetBBCThreshold(UShort_t th) {fBBCThreshold = th;};\r
 \r
@@ -133,12 +127,6 @@ public:
        Bool_t * GetPedestalSubtraction() const {return (Bool_t*) fPedestalSubtraction;};\r
        Bool_t GetPedestalSubtraction(Int_t board ) const  {return (board<kNCIUBoards?fPedestalSubtraction[board]:0);};\r
 \r
-       Float_t * GetTimeResolution() const {return (Float_t*) fTimeResolution;};\r
-       Float_t GetTimeResolution(Int_t board ) const  {return (board<kNCIUBoards?fTimeResolution[board]:0);};\r
-\r
-       Float_t * GetWidthResolution() const {return (Float_t*) fWidthResolution;};\r
-       Float_t GetWidthResolution(Int_t board ) const  {return (board<kNCIUBoards?fWidthResolution[board]:0);};\r
-\r
        UShort_t GetBBAThreshold() const {return fBBAThreshold;};\r
        UShort_t GetBBCThreshold() const {return fBBCThreshold;};\r
 \r
@@ -193,8 +181,6 @@ private:
        UShort_t fResetWin1[kNCIUBoards]; //Profil of the Clock of the Reset signal of Window 1 (BB window)\r
        UShort_t fResetWin2[kNCIUBoards]; //Profil of the Clock of the Reset signal of Window 2 (BG window)\r
        Bool_t   fPedestalSubtraction[kNCIUBoards]; // Flag to en(dis)able pedestal subtraction before centrality trigger calculation\r
-       Float_t  fTimeResolution[kNCIUBoards]; // Time Resolution of the TDC (ns / channel)\r
-       Float_t  fWidthResolution[kNCIUBoards]; // Time Width Resolution of the TDC (ns / channel)\r
        UShort_t fBBAThreshold;  // Minimum bias Threshold in number of channel hit for V0A\r
        UShort_t fBBCThreshold;  // Minimum bias Threshold in number of channel hit for V0C\r
        UShort_t fBGAThreshold;  // Beam Gas Threshold in number of channel hit for V0A\r
index 91b2b15..611f6ea 100644 (file)
@@ -8,7 +8,13 @@ man->SetDefaultStorage("local://$ALICE_ROOT/OCDB");
 
 // Setting gain and pedestal values :
 
-AliVZEROCalibData *calibda = new AliVZEROCalibData("Calib");
+AliVZEROCalibData *calibda = new AliVZEROCalibData("VZERO");
+       
+       UShort_t TimeResolution[8] = {0,0,0,0,0,0,0,0};
+       calibda->SetTimeResolution(TimeResolution);
+       
+       UShort_t WidthResolution[8] = {2,2,2,2,2,2,2,2};
+       calibda->SetWidthResolution(WidthResolution);
 
 Float_t Pedestals[128] =  
 { 16.0, 16.0, 16.0, 16.0, 16.0, 16.0, 16.0, 16.0, 16.0, 16.0,
@@ -162,7 +168,7 @@ AliCDBId id("VZERO/Calib/Data",0,9999999);
 //set to AliVZEROCalibData by the CDB classes during storage 
 md->SetResponsible("Brigitte Cheynis");
 md->SetBeamPeriod(0);
-md->SetAliRootVersion("October 2009");
+md->SetAliRootVersion("v4-17-Release");
 md->SetComment("Prototype");
 md->PrintMetaData();
 
index 0a0a7b4..134ee4c 100644 (file)
@@ -43,12 +43,6 @@ void DBStorageFEE(){
        
        UShort_t ResetWin2[N] = {16,16,16,16,16,16,16,16};
        triggerData->SetResetWin2(ResetWin2);
-       
-       UShort_t TimeResolution[N] = {0,0,0,0,0,0,0,0};
-       triggerData->SetTimeResolution(TimeResolution);
-       
-       UShort_t WidthResolution[N] = {2,2,2,2,2,2,2,2};
-       triggerData->SetWidthResolution(WidthResolution);
 
        Bool_t PedestalSubtraction[N] = {1,1,1,1,1,1,1,1};
        triggerData->SetPedestalSubtraction(PedestalSubtraction);
@@ -86,6 +80,7 @@ void DBStorageFEE(){
                }
        }
        
+       for(int i =0;i<5;i++) triggerData->SetTriggerSelected(i, i);
        
        // Creation of the object VZERO Trigger Configuration as a MetaData
        
@@ -99,7 +94,7 @@ void DBStorageFEE(){
        //set to AliVZEROCalibData by the CDB classes during storage 
        md->SetResponsible("Brigitte Cheynis");
        md->SetBeamPeriod(0);
-       md->SetAliRootVersion("January 2009");
+       md->SetAliRootVersion("v4-17-Release");
        md->SetComment("Prototype");
        md->PrintMetaData();
        
index cad5186..109e08d 100644 (file)
@@ -17,6 +17,85 @@ V00/FEE/CCIU/TriggerSelect2  2
 V00/FEE/CCIU/TriggerSelect3    3
 V00/FEE/CCIU/TriggerSelect4    4
 V00/FEE/CCIU/TriggerSelect5    5
+V00/FEE/CIU0/Clk1Win1                          3
+V00/FEE/CIU0/Clk2Win1  14
+V00/FEE/CIU0/Clk1Win2  7 
+V00/FEE/CIU0/Clk2Win2  14
+V00/FEE/CIU0/DelayClk1Win1     300
+V00/FEE/CIU0/DelayClk2Win1     200
+V00/FEE/CIU0/DelayClk1Win2     0
+V00/FEE/CIU0/DelayClk2Win2     100
+V00/FEE/CIU0/LatchWin1 16
+V00/FEE/CIU0/LatchWin2 16
+V00/FEE/CIU0/ResetWin1 16
+V00/FEE/CIU0/ResetWin2 16
+V00/FEE/CIU0/PedestalSubtraction       1
+V00/FEE/CIU0/EnableCharge1     1
+V00/FEE/CIU0/EnableCharge2     1
+V00/FEE/CIU0/EnableCharge3     1
+V00/FEE/CIU0/EnableCharge4     1
+V00/FEE/CIU0/EnableCharge5     1
+V00/FEE/CIU0/EnableCharge6     1
+V00/FEE/CIU0/EnableCharge7     1
+V00/FEE/CIU0/EnableCharge8     1
+V00/FEE/CIU0/EnableTiming1     1
+V00/FEE/CIU0/EnableTiming2     1
+V00/FEE/CIU0/EnableTiming3     1
+V00/FEE/CIU0/EnableTiming4     1
+V00/FEE/CIU0/EnableTiming5     1
+V00/FEE/CIU0/EnableTiming6     1
+V00/FEE/CIU0/EnableTiming7     1
+V00/FEE/CIU0/EnableTiming8     1
+V00/FEE/CIU0/PedEven1  16
+V00/FEE/CIU0/PedEven2  16
+V00/FEE/CIU0/PedEven3  16
+V00/FEE/CIU0/PedEven4  16
+V00/FEE/CIU0/PedEven5  16
+V00/FEE/CIU0/PedEven6  16
+V00/FEE/CIU0/PedEven7  16
+V00/FEE/CIU0/PedEven8  16
+V00/FEE/CIU0/PedOdd1   16
+V00/FEE/CIU0/PedOdd2   16
+V00/FEE/CIU0/PedOdd3   16
+V00/FEE/CIU0/PedOdd4   16
+V00/FEE/CIU0/PedOdd5   16
+V00/FEE/CIU0/PedOdd6   16
+V00/FEE/CIU0/PedOdd7   16
+V00/FEE/CIU0/PedOdd8   16
+V00/FEE/CIU0/PedCutEven1       18
+V00/FEE/CIU0/PedCutEven2       18
+V00/FEE/CIU0/PedCutEven3       18
+V00/FEE/CIU0/PedCutEven4       18
+V00/FEE/CIU0/PedCutEven5       18
+V00/FEE/CIU0/PedCutEven6       18
+V00/FEE/CIU0/PedCutEven7       18
+V00/FEE/CIU0/PedCutEven8       18
+V00/FEE/CIU0/PedCutOdd1        18
+V00/FEE/CIU0/PedCutOdd2        18
+V00/FEE/CIU0/PedCutOdd3        18
+V00/FEE/CIU0/PedCutOdd4        18
+V00/FEE/CIU0/PedCutOdd5        18
+V00/FEE/CIU0/PedCutOdd6        18
+V00/FEE/CIU0/PedCutOdd7        18
+V00/FEE/CIU0/PedCutOdd8        18
+V00/FEE/CIU0/DelayHit1 100
+V00/FEE/CIU0/DelayHit2 100
+V00/FEE/CIU0/DelayHit3 100
+V00/FEE/CIU0/DelayHit4 100
+V00/FEE/CIU0/DelayHit5 100
+V00/FEE/CIU0/DelayHit6 100
+V00/FEE/CIU0/DelayHit7 100
+V00/FEE/CIU0/DelayHit8 100
+V00/FEE/CIU0/DiscriThr1        2000
+V00/FEE/CIU0/DiscriThr2        2000
+V00/FEE/CIU0/DiscriThr3        2000
+V00/FEE/CIU0/DiscriThr4        2000
+V00/FEE/CIU0/DiscriThr5        2000
+V00/FEE/CIU0/DiscriThr6        2000
+V00/FEE/CIU0/DiscriThr7        2000
+V00/FEE/CIU0/DiscriThr8        2000
+V00/FEE/CIU0/TimeResolution 0
+V00/FEE/CIU0/WidthResolution 2
 V00/FEE/CIU1/Clk1Win1                          1
 V00/FEE/CIU1/Clk2Win1                          3
 V00/FEE/CIU1/Clk1Win2                          7 
@@ -94,6 +173,8 @@ V00/FEE/CIU1/DiscriThr5                              2000
 V00/FEE/CIU1/DiscriThr6                                2000
 V00/FEE/CIU1/DiscriThr7                                2000
 V00/FEE/CIU1/DiscriThr8                                2000
+V00/FEE/CIU1/TimeResolution 0
+V00/FEE/CIU1/WidthResolution 2
 V00/FEE/CIU2/Clk1Win1  1
 V00/FEE/CIU2/Clk2Win1  3
 V00/FEE/CIU2/Clk1Win2  7 
@@ -171,6 +252,8 @@ V00/FEE/CIU2/DiscriThr5     2000
 V00/FEE/CIU2/DiscriThr6        2000
 V00/FEE/CIU2/DiscriThr7        2000
 V00/FEE/CIU2/DiscriThr8        2000
+V00/FEE/CIU2/TimeResolution 0
+V00/FEE/CIU2/WidthResolution 2
 V00/FEE/CIU3/Clk1Win1                                  1
 V00/FEE/CIU3/Clk2Win1  3
 V00/FEE/CIU3/Clk1Win2  7 
@@ -248,6 +331,8 @@ V00/FEE/CIU3/DiscriThr5     2000
 V00/FEE/CIU3/DiscriThr6        2000
 V00/FEE/CIU3/DiscriThr7        2000
 V00/FEE/CIU3/DiscriThr8        2000
+V00/FEE/CIU3/TimeResolution 0
+V00/FEE/CIU3/WidthResolution 2
 V00/FEE/CIU4/Clk1Win1                                          1
 V00/FEE/CIU4/Clk2Win1  3
 V00/FEE/CIU4/Clk1Win2  7 
@@ -325,6 +410,8 @@ V00/FEE/CIU4/DiscriThr5     2000
 V00/FEE/CIU4/DiscriThr6        2000
 V00/FEE/CIU4/DiscriThr7        2000
 V00/FEE/CIU4/DiscriThr8        2000
+V00/FEE/CIU4/TimeResolution 0
+V00/FEE/CIU4/WidthResolution 2
 V00/FEE/CIU5/Clk1Win1                          3
 V00/FEE/CIU5/Clk2Win1  14
 V00/FEE/CIU5/Clk1Win2  7 
@@ -402,6 +489,8 @@ V00/FEE/CIU5/DiscriThr5     2000
 V00/FEE/CIU5/DiscriThr6        2000
 V00/FEE/CIU5/DiscriThr7        2000
 V00/FEE/CIU5/DiscriThr8        2000
+V00/FEE/CIU5/TimeResolution 0
+V00/FEE/CIU5/WidthResolution 2
 V00/FEE/CIU6/Clk1Win1                          3
 V00/FEE/CIU6/Clk2Win1  14
 V00/FEE/CIU6/Clk1Win2  7 
@@ -479,6 +568,8 @@ V00/FEE/CIU6/DiscriThr5     2000
 V00/FEE/CIU6/DiscriThr6        2000
 V00/FEE/CIU6/DiscriThr7        2000
 V00/FEE/CIU6/DiscriThr8        2000
+V00/FEE/CIU6/TimeResolution 0
+V00/FEE/CIU6/WidthResolution 2
 V00/FEE/CIU7/Clk1Win1                          3
 V00/FEE/CIU7/Clk2Win1  14
 V00/FEE/CIU7/Clk1Win2  7 
@@ -556,83 +647,8 @@ V00/FEE/CIU7/DiscriThr5    2000
 V00/FEE/CIU7/DiscriThr6        2000
 V00/FEE/CIU7/DiscriThr7        2000
 V00/FEE/CIU7/DiscriThr8        2000
-V00/FEE/CIU8/Clk1Win1                          3
-V00/FEE/CIU8/Clk2Win1  14
-V00/FEE/CIU8/Clk1Win2  7 
-V00/FEE/CIU8/Clk2Win2  14
-V00/FEE/CIU8/DelayClk1Win1     300
-V00/FEE/CIU8/DelayClk2Win1     200
-V00/FEE/CIU8/DelayClk1Win2     0
-V00/FEE/CIU8/DelayClk2Win2     100
-V00/FEE/CIU8/LatchWin1 16
-V00/FEE/CIU8/LatchWin2 16
-V00/FEE/CIU8/ResetWin1 16
-V00/FEE/CIU8/ResetWin2 16
-V00/FEE/CIU8/PedestalSubtraction       1
-V00/FEE/CIU8/EnableCharge1     1
-V00/FEE/CIU8/EnableCharge2     1
-V00/FEE/CIU8/EnableCharge3     1
-V00/FEE/CIU8/EnableCharge4     1
-V00/FEE/CIU8/EnableCharge5     1
-V00/FEE/CIU8/EnableCharge6     1
-V00/FEE/CIU8/EnableCharge7     1
-V00/FEE/CIU8/EnableCharge8     1
-V00/FEE/CIU8/EnableTiming1     1
-V00/FEE/CIU8/EnableTiming2     1
-V00/FEE/CIU8/EnableTiming3     1
-V00/FEE/CIU8/EnableTiming4     1
-V00/FEE/CIU8/EnableTiming5     1
-V00/FEE/CIU8/EnableTiming6     1
-V00/FEE/CIU8/EnableTiming7     1
-V00/FEE/CIU8/EnableTiming8     1
-V00/FEE/CIU8/PedEven1  16
-V00/FEE/CIU8/PedEven2  16
-V00/FEE/CIU8/PedEven3  16
-V00/FEE/CIU8/PedEven4  16
-V00/FEE/CIU8/PedEven5  16
-V00/FEE/CIU8/PedEven6  16
-V00/FEE/CIU8/PedEven7  16
-V00/FEE/CIU8/PedEven8  16
-V00/FEE/CIU8/PedOdd1   16
-V00/FEE/CIU8/PedOdd2   16
-V00/FEE/CIU8/PedOdd3   16
-V00/FEE/CIU8/PedOdd4   16
-V00/FEE/CIU8/PedOdd5   16
-V00/FEE/CIU8/PedOdd6   16
-V00/FEE/CIU8/PedOdd7   16
-V00/FEE/CIU8/PedOdd8   16
-V00/FEE/CIU8/PedCutEven1       18
-V00/FEE/CIU8/PedCutEven2       18
-V00/FEE/CIU8/PedCutEven3       18
-V00/FEE/CIU8/PedCutEven4       18
-V00/FEE/CIU8/PedCutEven5       18
-V00/FEE/CIU8/PedCutEven6       18
-V00/FEE/CIU8/PedCutEven7       18
-V00/FEE/CIU8/PedCutEven8       18
-V00/FEE/CIU8/PedCutOdd1        18
-V00/FEE/CIU8/PedCutOdd2        18
-V00/FEE/CIU8/PedCutOdd3        18
-V00/FEE/CIU8/PedCutOdd4        18
-V00/FEE/CIU8/PedCutOdd5        18
-V00/FEE/CIU8/PedCutOdd6        18
-V00/FEE/CIU8/PedCutOdd7        18
-V00/FEE/CIU8/PedCutOdd8        18
-V00/FEE/CIU8/DelayHit1 100
-V00/FEE/CIU8/DelayHit2 100
-V00/FEE/CIU8/DelayHit3 100
-V00/FEE/CIU8/DelayHit4 100
-V00/FEE/CIU8/DelayHit5 100
-V00/FEE/CIU8/DelayHit6 100
-V00/FEE/CIU8/DelayHit7 100
-V00/FEE/CIU8/DelayHit8 100
-V00/FEE/CIU8/DiscriThr1        2000
-V00/FEE/CIU8/DiscriThr2        2000
-V00/FEE/CIU8/DiscriThr3        2000
-V00/FEE/CIU8/DiscriThr4        2000
-V00/FEE/CIU8/DiscriThr5        2000
-V00/FEE/CIU8/DiscriThr6        2000
-V00/FEE/CIU8/DiscriThr7        2000
-V00/FEE/CIU8/DiscriThr8        2000
+V00/FEE/CIU7/TimeResolution 0
+V00/FEE/CIU7/WidthResolution 2
 V00/HV/V0A/SECTOR0/RING0        1784
 V00/HV/V0A/SECTOR0/RING1        1813
 V00/HV/V0A/SECTOR0/RING2        1738
@@ -696,4 +712,4 @@ V00/HV/V0C/SECTOR6/RING3        1859
 V00/HV/V0C/SECTOR7/RING0        1860
 V00/HV/V0C/SECTOR7/RING1        1795
 V00/HV/V0C/SECTOR7/RING2        1808
-V00/HV/V0C/SECTOR7/RING3        1670
\ No newline at end of file
+V00/HV/V0C/SECTOR7/RING3        1670
index 09890d3..2cb4bbf 100644 (file)
@@ -15,7 +15,7 @@ void VZEROTestPreprocessor()
 
    // create AliTestShuttle instance
   // The parameters are run, startTime, endTime
-  AliTestShuttle* shuttle = new AliTestShuttle(0, 0, 1);
+  AliTestShuttle* shuttle = new AliTestShuttle(12345, 0, 123450);
 
   // TODO if needed, change location of OCDB and Reference test folders
   // by default they are set to $ALICE_ROOT/SHUTTLE/TestShuttle/TestCDB and TestReference
@@ -163,8 +163,10 @@ TMap* CreateDCSAliasMap()
                valueSet->Add(dcsVal);
                
                if(aliasName.Contains("HV")) {
-                       dcsVal = new AliDCSValue((Float_t) (val+random.Gaus(0,100)), timeStamp+10);
-                       valueSet->Add(dcsVal);
+                       for(int i=0;i<10;i++){
+                               dcsVal = new AliDCSValue((Float_t) (val+random.Gaus(0,10)), timeStamp+10*i);
+                               valueSet->Add(dcsVal);
+                       }
                }
                
                aliasMap->Add(new TObjString(aliasName), valueSet);