Change of STANDALONE run types in Preprocessor + retrieval and use of two more FEE...
authorcheynis <cheynis@f7af4fe6-9843-0410-8265-dc069ae4e863>
Wed, 14 Oct 2009 10:06:50 +0000 (10:06 +0000)
committercheynis <cheynis@f7af4fe6-9843-0410-8265-dc069ae4e863>
Wed, 14 Oct 2009 10:06:50 +0000 (10:06 +0000)
VZERO/AliVZERODataFEE.cxx
VZERO/AliVZERODataFEE.h
VZERO/AliVZEROPreprocessor.cxx
VZERO/AliVZEROQADataMakerRec.cxx
VZERO/AliVZERORawStream.cxx
VZERO/AliVZEROReconstructor.cxx
VZERO/AliVZEROReconstructor.h
VZERO/AliVZEROTriggerData.cxx
VZERO/AliVZEROTriggerData.h
VZERO/DBStorageFEE.C

index 983b2c7..84f316a 100644 (file)
@@ -152,9 +152,6 @@ void AliVZERODataFEE::ProcessData(TMap& aliasMap){
                \r
        }\r
        \r
-       // calculate mean and rms of the first two histos\r
-       // and convert index to aliroot channel\r
-    \r
        fIsProcessed=kTRUE;\r
        \r
 }\r
@@ -181,14 +178,16 @@ 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 = "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
+               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
        }\r
        return result;\r
 }\r
index 44a7829..9467c12 100644 (file)
@@ -38,7 +38,7 @@ public:
        \r
        TMap * GetParameters() const {return fParameters;};\r
        \r
-       enum { kNCIUBoards = 8, kNCIUParam = 13, kNChannelParam = 8, kNCCIUParam = 19, kNAliases  = kNChannelParam*8*kNCIUBoards +kNCIUParam*kNCIUBoards + kNCCIUParam };\r
+       enum { kNCIUBoards = 8, kNCIUParam = 15, kNChannelParam = 8, kNCCIUParam = 19, kNAliases  = kNChannelParam*8*kNCIUBoards +kNCIUParam*kNCIUBoards + kNCCIUParam };\r
 \r
 private:\r
        \r
index 3fab728..379c66c 100644 (file)
@@ -38,7 +38,8 @@ AliVZEROPreprocessor::AliVZEROPreprocessor(AliShuttleInterface* shuttle) :
 {
   // constructor  
   
-  AddRunType("STANDALONE");
+  AddRunType("STANDALONE_PULSER");
+  AddRunType("STANDALONE_BC");
   AddRunType("PHYSICS");
     
 }
index 20afb86..a23cefd 100644 (file)
@@ -45,6 +45,7 @@
 #include "AliVZEROdigit.h"
 #include "AliVZEROReconstructor.h"
 #include "AliVZEROTrending.h"
+#include "AliVZEROCalibData.h"
 #include "event.h"
 
 
@@ -142,7 +143,7 @@ void AliVZEROQADataMakerRec::EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjA
        } else if ((TMath::Abs(fTrendingUpdateTime * fMonitorRate - fTrendingUpdateEvent) / fTrendingUpdateEvent) > 0.1){
                update = kTRUE;
        }
-       if(update) fTrendingUpdateEvent = fTrendingUpdateTime * fMonitorRate;
+       if(update) fTrendingUpdateEvent = (size_t)(fTrendingUpdateTime * fMonitorRate);
        //printf("Update trending information every %d events\n",fTrendingUpdateEvent); 
 
   }
@@ -584,8 +585,8 @@ void AliVZEROQADataMakerRec::MakeESDs(AliESDEvent * esd)
      InitRaws() ;
 
    rawReader->Reset() ; 
-   AliVZERORawStream rawStream(rawReader); 
-   if(!(rawStream.Next())) return;  
+  AliVZERORawStream* rawStream  = new AliVZERORawStream(rawReader); 
+ if(!(rawStream->Next())) return;  
  
   eventTypeType eventType = rawReader->GetType();
 
@@ -613,7 +614,7 @@ void AliVZEROQADataMakerRec::MakeESDs(AliESDEvent * esd)
        Int_t  integrator;
        Bool_t BBFlag;   
        Bool_t BGFlag;   
-       UInt_t time, width;
+       Float_t time, width;
        Int_t  MBCharge;
           Float_t charge;
        Int_t  offlineCh;
@@ -621,18 +622,18 @@ void AliVZEROQADataMakerRec::MakeESDs(AliESDEvent * esd)
 
        for(Int_t iChannel=0; iChannel<64; iChannel++) { // BEGIN : Loop over channels
                   
-          offlineCh = rawStream.GetOfflineChannel(iChannel);
+          offlineCh = rawStream->GetOfflineChannel(iChannel);
                   
           // Fill Pedestal histograms
           
            for(Int_t j=15; j<21; j++) {
-                      if((rawStream.GetBGFlag(iChannel,j) || rawStream.GetBBFlag(iChannel,j))) iFlag++;
+                      if((rawStream->GetBGFlag(iChannel,j) || rawStream->GetBBFlag(iChannel,j))) iFlag++;
            }
 
            if(iFlag == 0){ //No Flag found
                       for(Int_t j=15; j<21; j++){
-                              pedestal=rawStream.GetPedestal(iChannel, j);
-                              integrator = rawStream.GetIntegratorFlag(iChannel, j);
+                              pedestal= (Int_t) rawStream->GetPedestal(iChannel, j);
+                              integrator = rawStream->GetIntegratorFlag(iChannel, j);
 
                               GetRawsData((integrator == 0 ? kPedestalInt0 : kPedestalInt1))->Fill(offlineCh,pedestal);
                               GetRawsData((integrator == 0 ? kPedestalCycleInt0 : kPedestalCycleInt1))->Fill(offlineCh,pedestal);
@@ -646,16 +647,16 @@ void AliVZEROQADataMakerRec::MakeESDs(AliESDEvent * esd)
            Int_t iClock  = 0;
            Float_t iCharge = 0;
            for(Int_t iEvent=0; iEvent<21; iEvent++){
-               iCharge = rawStream.GetPedestal(iChannel,iEvent);
+               iCharge = rawStream->GetPedestal(iChannel,iEvent);
                if(iCharge>charge)  {
                       charge = iCharge;
                       iClock = iEvent;
                   }
            }   // End of maximum searching procedure
 
-           integrator    = rawStream.GetIntegratorFlag(iChannel,iClock);
-           BBFlag       = rawStream.GetBBFlag(iChannel, iClock);
-           BGFlag       = rawStream.GetBGFlag(iChannel,iClock );
+           integrator    = rawStream->GetIntegratorFlag(iChannel,iClock);
+           BBFlag       = rawStream->GetBBFlag(iChannel, iClock);
+           BGFlag       = rawStream->GetBGFlag(iChannel,iClock );
 
            GetRawsData((integrator == 0 ? kChargeEoIInt0 : kChargeEoIInt1))->Fill(offlineCh,charge);
           if(BBFlag) GetRawsData((integrator == 0 ? kChargeEoIBBInt0 : kChargeEoIBBInt1))->Fill(offlineCh,charge);
@@ -694,10 +695,10 @@ void AliVZEROQADataMakerRec::MakeESDs(AliESDEvent * esd)
                   
           int idx;
           for(Int_t iBunch=0; iBunch<10; iBunch++){
-                          integrator = rawStream.GetIntMBFlag(iChannel, iBunch);
-                          BBFlag     = rawStream.GetBBMBFlag(iChannel, iBunch);
-                          BGFlag     = rawStream.GetBGMBFlag(iChannel, iBunch);
-                          MBCharge   = rawStream.GetChargeMB(iChannel, iBunch);
+                          integrator = rawStream->GetIntMBFlag(iChannel, iBunch);
+                          BBFlag     = rawStream->GetBBMBFlag(iChannel, iBunch);
+                          BGFlag     = rawStream->GetBGMBFlag(iChannel, iBunch);
+                          MBCharge   = rawStream->GetChargeMB(iChannel, iBunch);
 
                           if(integrator==0){
                                   if(BBFlag==0){
@@ -721,10 +722,10 @@ void AliVZEROQADataMakerRec::MakeESDs(AliESDEvent * esd)
 
          // Fill HPTDC Time Histograms
 
-          BBFlag   = rawStream.GetBBFlag(iChannel, 10);
-           BGFlag   = rawStream.GetBGFlag(iChannel, 10);
-           time     = rawStream.GetTime(iChannel);
-           width    = rawStream.GetWidth(iChannel);
+          BBFlag   = rawStream->GetBBFlag(iChannel, 10);
+           BGFlag   = rawStream->GetBGFlag(iChannel, 10);
+           time     = rawStream->GetTime(iChannel);
+           width    = rawStream->GetWidth(iChannel);
 
           if(time>0.){
                      if (offlineCh<32) {
@@ -749,10 +750,10 @@ void AliVZEROQADataMakerRec::MakeESDs(AliESDEvent * esd)
           // Fill Flag and Charge Versus LHC-Clock histograms
           
           for(Int_t iEvent=0; iEvent<21; iEvent++){
-               charge = rawStream.GetPedestal(iChannel,iEvent);
-               integrator = rawStream.GetIntegratorFlag(iChannel,iEvent);
-               BBFlag    = rawStream.GetBBFlag(iChannel, iEvent);
-               BGFlag    = rawStream.GetBGFlag(iChannel,iEvent );
+               charge = rawStream->GetPedestal(iChannel,iEvent);
+               integrator = rawStream->GetIntegratorFlag(iChannel,iEvent);
+               BBFlag    = rawStream->GetBBFlag(iChannel, iEvent);
+               BGFlag    = rawStream->GetBGFlag(iChannel,iEvent );
 
                ((TH2*) GetRawsData((integrator == 0 ? kChargeVsClockInt0 : kChargeVsClockInt1 )))->Fill(offlineCh,(float)iEvent-10,(float)charge);
                ((TH2*) GetRawsData(kBBFlagVsClock))->Fill(offlineCh,(float)iEvent-10,(float)BBFlag);
@@ -820,6 +821,8 @@ void AliVZEROQADataMakerRec::MakeESDs(AliESDEvent * esd)
        p = dynamic_cast<TParameter<double>*>(GetParameterList()->FindObject(Form("%s_%s_%s", GetName(), AliQAv1::GetTaskName(AliQAv1::kRAWS).Data(), GetRawsData(kDiffTime)->GetName()))) ; 
        if (p) p->SetVal((double)diffTime) ;                     
        
+       delete rawStream; rawStream = 0x0;      
+
 
  }
 
index 0c13c1c..1d1306d 100644 (file)
@@ -189,7 +189,7 @@ Bool_t AliVZERORawStream::Next()
        Float_t fine     = 25. / 256. * (time & 0x1f);
        // fTime[iChannel] = time & 0xfff;
        fTime[iChannel]  = coarse1 + coarse2 + fine;
-       fWidth[iChannel] = 3.2 * ( (time >> 12) & 0x7f);   // HPTDC used in pairing mode
+       fWidth[iChannel] = 0.4 * ( (time >> 12) & 0x7f);   // HPTDC used in pairing mode
     }
     
     // End of decoding of one CIU card
index 4a0ccbc..ef21723 100644 (file)
@@ -34,6 +34,8 @@
 #include "AliESDfriend.h"
 #include "AliESDVZEROfriend.h"
 #include "AliVZEROdigit.h"
+#include "AliVZEROCalibData.h"
+#include "AliVZEROTriggerData.h"
 
 ClassImp(AliVZEROReconstructor)
 
@@ -43,6 +45,7 @@ AliVZEROReconstructor:: AliVZEROReconstructor(): AliReconstructor(),
                         fESD(0x0),
                         fESDVZEROfriend(0x0),
                         fCalibData(GetCalibData()),
+                        fTriggerData(GetTriggerData()),
                         fCollisionMode(0),
                         fBeamEnergy(0.)
 {
@@ -117,9 +120,10 @@ void AliVZEROReconstructor::ConvertDigits(AliRawReader* rawReader, TTree* digits
          }
         // Convert i (FEE channel numbering) to j (aliroot channel numbering)
         Int_t j       =  rawStream.GetOfflineChannel(i);
+        Int_t board   = j / 8;
         adc[j]        =  ADC_max[i];
-        time[j]       =  rawStream.GetTime(i);
-        width[j]      =  rawStream.GetWidth(i);
+        time[j]       =  rawStream.GetTime(i)/ (25./256.) * fTriggerData->GetTimeResolution(board);
+        width[j]      =  rawStream.GetWidth(i) / 0.4 * fTriggerData->GetWidthResolution(board);
         BBFlag[j]     =  rawStream.GetBBFlag(i,imax);
         BGFlag[j]     =  rawStream.GetBGFlag(i,imax); 
         integrator[j] =  rawStream.GetIntegratorFlag(i,imax); 
@@ -139,8 +143,8 @@ void AliVZEROReconstructor::ConvertDigits(AliRawReader* rawReader, TTree* digits
             fESDVZEROfriend->SetBBFlag(j,iEv,rawStream.GetBBFlag(i,iEv));
             fESDVZEROfriend->SetBGFlag(j,iEv,rawStream.GetBGFlag(i,iEv));
         }
-        fESDVZEROfriend->SetTime(j,rawStream.GetTime(i));
-        fESDVZEROfriend->SetWidth(j,rawStream.GetWidth(i));
+        fESDVZEROfriend->SetTime(j,time[j]);
+        fESDVZEROfriend->SetWidth(j,width[j]);
      }  
 
      // Filling the esd friend object
@@ -369,3 +373,32 @@ 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 814cb5b..0ee2c61 100644 (file)
 #include "AliCDBStorage.h"
 #include "AliCDBEntry.h"
 
-#include "AliVZEROCalibData.h"
 #include "AliLog.h"
 #include "AliESDVZERO.h"
 
+class AliVZEROCalibData;
+class AliVZEROTriggerData;
 class AliESDEvent;
 class AliESDVZEROfriend;
 
@@ -48,6 +49,7 @@ public:
   void GetCollisionMode();
   
   AliVZEROCalibData *GetCalibData() const; 
+  AliVZEROTriggerData *GetTriggerData() const; 
 
 protected:
   AliESDVZERO*        fESDVZERO;       // ESD output object  
@@ -55,10 +57,11 @@ protected:
   AliESDVZEROfriend*  fESDVZEROfriend; // ESD friend object (complete raw data)
   
 private:
-  AliVZEROReconstructor(const AliVZEROReconstructor&); //Not implemented
-  AliVZEROReconstructor& operator = (const AliVZEROReconstructor&); //Not implemented
+  AliVZEROReconstructor(const AliVZEROReconstructor& reconstructor);
+  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
index 4bf1e11..a3b9ad0 100644 (file)
@@ -62,6 +62,8 @@ 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
@@ -95,6 +97,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
        SetName(namst.Data());\r
@@ -115,10 +119,12 @@ void AliVZEROTriggerData::FillData(AliVZERODataFEE * data){
        \r
        while ((  aliasName = (TObjString*) iter.Next() ))  {\r
                AliDCSValue* aValue = (AliDCSValue*) params->GetValue(aliasName);\r
-               Float_t val = aValue->GetFloat();\r
-               //AliInfo(Form("%s : %f",aliasName->String().Data(), val));\r
-               SetParameter(aliasName->String(),val);\r
-       \r
+               Float_t val;\r
+               if(aValue) {\r
+                       val = aValue->GetFloat();\r
+                       //AliInfo(Form("%s : %f",aliasName->String().Data(), val));\r
+                       SetParameter(aliasName->String(),val);\r
+               }\r
        }       \r
 }\r
 \r
@@ -151,6 +157,8 @@ 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
@@ -476,6 +484,105 @@ 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 1ceb7c9..29d0cc9 100644 (file)
@@ -61,6 +61,12 @@ 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
@@ -127,6 +133,12 @@ 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
@@ -181,6 +193,8 @@ 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 ab9b16b..0a0a7b4 100644 (file)
@@ -43,6 +43,12 @@ 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);