T0/AliT0Parameters.cxx

   1 /**************************************************************************
   2  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
   3  *                                                                        *
   4  * Author: The ALICE Off-line Project.                                    *
   5  * Contributors are mentioned in the code where appropriate.              *
   6  *                                                                        *
   7  * Permission to use, copy, modify and distribute this software and its   *
   8  * documentation strictly for non-commercial purposes is hereby granted   *
   9  * without fee, provided that the above copyright notice appears in all   *
  10  * copies and that both the copyright notice and this permission notice   *
  11  * appear in the supporting documentation. The authors make no claims     *
  12  * about the suitability of this software for any purpose. It is          *
  13  * provided "as is" without express or implied warranty.                  *
  14  **************************************************************************/
  15
  16 /* $Id:  */
  17
  18 //____________________________________________________________________
  19 //
  20 // T0 - T0.
  21 //
  22 // This class is a singleton that handles various parameters of
  23 // the T0 detectors.
  24 // Eventually, this class will use the Conditions DB to get the
  25 // various parameters, which code can then request from here.
  26 //
  27 #include "AliLog.h"
  28 #include "AliT0Parameters.h"
  29 #include "AliT0CalibData.h"
  30 #include "AliT0LookUpValue.h"
  31 #include <AliCDBManager.h>
  32 #include <AliCDBEntry.h>
  33 #include <AliCDBStorage.h>
  34 #include <Riostream.h>
  35
  36 AliT0CalibData* AliT0Parameters::fgCalibData = 0;
  37 AliT0CalibData* AliT0Parameters::fgLookUp = 0;
  38 AliT0CalibData* AliT0Parameters::fgSlewCorr =0;
  39 //====================================================================
  40 ClassImp(AliT0Parameters)
  41 #if 0
  42   ; // This is here to keep Emacs for indenting the next line
  43 #endif
  44
  45 //____________________________________________________________________
  46 AliT0Parameters* AliT0Parameters::fgInstance = 0;
  47 //____________________________________________________________________
  48 AliT0Parameters*
  49 AliT0Parameters::Instance()
  50 {
  51   // Get static instance
  52   if (!fgInstance) fgInstance = new AliT0Parameters;
  53   return fgInstance;
  54 }
  55
  56 //____________________________________________________________________
  57 AliT0Parameters::AliT0Parameters()
  58   :fIsInit(kFALSE),fPh2Mip(0),fmV2Mip(0),fChannelWidth(0),fmV2Channel(0),fQTmin(0),fQTmax(0),fSlewingLED(),fSlewingRec(),fPMTeff(),fTimeDelayLED(0),fTimeDelayCFD(0),fTimeDelayTVD(0),fCalibentry(), fLookUpentry(),fSlewCorr()
  59 {
  60   // Default constructor
  61
  62   for (Int_t ipmt=0; ipmt<24; ipmt++)
  63     {
  64       SetSlewingLED(ipmt);
  65       SetSlewingRec(ipmt);
  66       SetWalk(ipmt);
  67       SetPh2Mip();
  68       SetmV2Mip();
  69       SetChannelWidth();
  70       SetmV2channel();
  71       SetQTmin();
  72       SetQTmax();
  73       SetPMTeff(ipmt);
  74
  75    }
  76   SetTimeDelayTVD();
  77   SetZposition();
  78
  79 }
  80
  81 //__________________________________________________________________
  82 void
  83 AliT0Parameters::Init()
  84 {
  85   // Initialize the parameters manager.  We need to get stuff from the
  86   // CDB here.
  87   //   if (fIsInit) return;
  88
  89   // AliCDBManager* cdb      = AliCDBManager::Instance();
  90   // fCalibentry  = cdb->Get("T0/Calib/Gain_TimeDelay_Slewing_Walk");
  91
  92
  93   AliCDBStorage *stor =AliCDBManager::Instance()->GetStorage("local://$ALICE_ROOT");
  94   //time equalizing
  95   AliCDBEntry* fCalibentry  = stor->Get("T0/Calib/TimeDelay",0);
  96  if (fCalibentry){
  97    fgCalibData  = (AliT0CalibData*)fCalibentry->GetObject();
  98   }
  99  else
 100    { AliError(" ALARM !!!! No time delays in CDB "); }
 101  //slewing correction
 102   AliCDBEntry* fSlewCorr  = stor->Get("T0/Calib/Slewing_Walk",0);
 103  if (fSlewCorr){
 104    fgSlewCorr  = (AliT0CalibData*)fSlewCorr->GetObject();
 105   }
 106  // fLookUpentry  = cdb->Get("T0/Calib/LookUp_Table");
 107   fLookUpentry  = stor->Get("T0/Calib/LookUp_Table",0);
 108   if (fLookUpentry){
 109     fgLookUp  = (AliT0CalibData*)fLookUpentry->GetObject();
 110     //   fgLookUp->Dump();
 111   }
 112   else {
 113     fgLookUp->ReadAsciiLookup("$ALICE_ROOT/T0/lookUpTable.txt");
 114   }
 115
 116   fIsInit = kTRUE;
 117 }
 118
 119
 120 //__________________________________________________________________
 121 Float_t
 122 AliT0Parameters::GetTimeDelayLED(Int_t ipmt)
 123 {
 124   // return time delay for LED channel
 125   //
 126   if (!fCalibentry) {
 127     fTimeDelayLED = 0;
 128     return  fTimeDelayLED;
 129   }
 130   return fgCalibData ->GetTimeDelayLED(ipmt);
 131 }
 132 //__________________________________________________________________
 133 Float_t
 134 AliT0Parameters::GetTimeDelayCFD(Int_t ipmt)
 135 {
 136   // return time delay for CFD channel
 137    //
 138   if (!fCalibentry)
 139     {
 140       fTimeDelayCFD = 1000+ipmt*100;
 141       return fTimeDelayCFD;
 142     }
 143
 144   return fgCalibData->GetTimeDelayCFD(ipmt);
 145 }
 146
 147 //__________________________________________________________________
 148
 149 void
 150 AliT0Parameters::SetSlewingLED(Int_t ipmt)
 151 {
 152   //  Set Slweing Correction for LED channel
 153      Float_t mv[23] = {25, 30,40,60, 80,100,150,200,250,300,
 154                        400,500,600,800,1000,1500, 2000, 3000, 4000, 5500,
 155                        6000, 7000,8000};
 156       Float_t y[23] = {5044, 4719, 3835, 3224, 2847, 2691,2327, 2067, 1937, 1781,
 157                        1560, 1456 ,1339, 1163.5, 1027, 819, 650, 520, 370.5, 234,
 158                        156, 78, 0};
 159
 160       TGraph* gr = new TGraph(23,mv,y);
 161       fSlewingLED.AddAtAndExpand(gr,ipmt);
 162   }
 163 //__________________________________________________________________
 164
 165 Float_t AliT0Parameters::GetSlewingLED(Int_t ipmt, Float_t mv) const
 166 {
 167   if (!fCalibentry) {
 168     return ((TGraph*)fSlewingLED.At(ipmt))->Eval(mv);
 169   }
 170   return fgCalibData->GetSlewingLED(ipmt, mv) ;
 171 }
 172
 173
 174 //__________________________________________________________________
 175
 176 TGraph *AliT0Parameters::GetSlew(Int_t ipmt) const
 177 {
 178   if (!fCalibentry) {
 179     return  (TGraph*)fSlewingLED.At(ipmt);
 180   }
 181   return fgCalibData -> GetSlew(ipmt) ;
 182 }
 183
 184 //__________________________________________________________________
 185
 186
 187 void
 188 AliT0Parameters::SetSlewingRec(Int_t ipmt)
 189 {
 190   //  Set Slweing Correction for LED channel
 191       Float_t mv[23] = {25, 30, 40,60, 80,100,150,200,250,300,
 192                         400,500,600,800,1000,1500, 2000, 3000, 4000, 5500,
 193                         6000, 7000,8000};
 194       Float_t y[23] = {5044, 4719, 3835, 3224, 2847, 2691,2327, 2067, 1937, 1781,
 195                        1560, 1456 ,1339, 1163.5, 1027, 819, 650, 520, 370.5, 234,
 196                        156, 78, 0};
 197       Float_t y1[23], mv1[23];
 198       for (Int_t i=0; i<23; i++){
 199         y1[i] = y[22-i]; mv1[i] = mv[22-i];}
 200
 201       TGraph* gr = new TGraph(23,y1,mv1);
 202       fSlewingRec.AddAtAndExpand(gr,ipmt);
 203
 204 }
 205 //__________________________________________________________________
 206
 207 Float_t AliT0Parameters::GetSlewingRec(Int_t ipmt, Float_t mv) const
 208 {
 209   if (!fCalibentry) {
 210     return ((TGraph*)fSlewingRec.At(ipmt))->Eval(mv);
 211   }
 212   return fgCalibData -> GetSlewingRec(ipmt, mv) ;
 213 }
 214
 215 //__________________________________________________________________
 216
 217 TGraph *AliT0Parameters::GetSlewRec(Int_t ipmt) const
 218 {
 219   if (!fCalibentry) {
 220     return  (TGraph*)fSlewingRec.At(ipmt);
 221   }
 222   return fgCalibData -> GetSlewRec(ipmt) ;
 223 }
 224
 225
 226 //________________________________________________________________
 227 void AliT0Parameters::SetWalk(Int_t ipmt)
 228 {
 229
 230  Int_t mv, ps;
 231   Int_t x[70000], y[70000], index[70000];
 232   Float_t time[10000],amplitude[10000];
 233   string buffer;
 234   Bool_t down=false;
 235
 236   ifstream inFile("data/CFD-Amp.txt");
 237   //  if(!inFile) AliError(Form("Cannot open file %s !",filename));
 238
 239   Int_t i=0, i1=0, i2=0;
 240   while(getline(inFile,buffer)){
 241     inFile >> ps >> mv;
 242
 243     x[i]=ps; y[i]=mv;
 244     i++;
 245   }
 246   inFile.close();
 247
 248   TMath::Sort(i, y, index,down);
 249   Int_t amp=0, iin=0, isum=0, sum=0;
 250   Int_t ind=0;
 251   for (Int_t ii=0; ii<70000; ii++)
 252     {
 253       ind=index[ii];
 254       if(y[ind] == amp)
 255         {
 256           sum +=x[ind];
 257           iin++;
 258         }
 259       else
 260         {
 261           if(iin>0)
 262             time[isum] = Float_t (sum/(iin));
 263           else
 264             time[isum] =Float_t (x[ind]);
 265           amplitude[isum] = Float_t (amp);
 266           amp=y[ind];
 267           //      cout<<ii<<" "<<ind<<" "<<y[ind]<<" "<<x[ind]<<" iin "<<iin<<" mean "<<time[isum]<<" amp "<< amplitude[isum]<<" "<<isum<<endl;
 268           iin=0;
 269           isum++;
 270           sum=0;
 271         }
 272
 273
 274     }
 275
 276   inFile.close();
 277
 278    TGraph* gr = new TGraph(isum, amplitude, time);
 279   fWalk.AddAtAndExpand(gr,ipmt);
 280
 281
 282 }
 283 //__________________________________________________________________
 284
 285 TGraph *AliT0Parameters::GetWalk(Int_t ipmt) const
 286 {
 287   if (!fCalibentry) {
 288     return  (TGraph*)fWalk.At(ipmt);
 289   }
 290   return fgCalibData -> GetWalk(ipmt) ;
 291 }
 292
 293 //__________________________________________________________________
 294
 295 Float_t AliT0Parameters::GetWalkVal(Int_t ipmt, Float_t mv) const
 296 {
 297   if (!fCalibentry) {
 298     return ((TGraph*)fWalk.At(ipmt))->Eval(mv);
 299   }
 300   return fgCalibData -> GetWalkVal(ipmt, mv) ;
 301 }
 302
 303 //__________________________________________________________________
 304
 305 //__________________________________________________________________
 306 void
 307 AliT0Parameters::SetPMTeff(Int_t ipmt)
 308 {
 309   Float_t lambda[50];
 310   Float_t eff[50 ] = {0,        0,       0.23619,  0.202909, 0.177913,
 311                     0.175667, 0.17856, 0.190769, 0.206667, 0.230286,
 312                     0.252276, 0.256267,0.26,     0.27125,  0.281818,
 313                     0.288118, 0.294057,0.296222, 0.301622, 0.290421,
 314                     0.276615, 0.2666,  0.248,    0.23619,  0.227814,
 315                     0.219818, 0.206667,0.194087, 0.184681, 0.167917,
 316                     0.154367, 0.1364,  0.109412, 0.0834615,0.0725283,
 317                     0.0642963,0.05861, 0.0465,   0.0413333,0.032069,
 318                     0.0252203,0.02066, 0.016262, 0.012,    0.00590476,
 319                     0.003875, 0.00190, 0,        0,        0          } ;
 320   for (Int_t i=0; i<50; i++) lambda[i]=200+10*i;
 321
 322   TGraph* gr = new TGraph(50,lambda,eff);
 323   fPMTeff.AddAtAndExpand(gr,ipmt);
 324 }
 325 //________________________________________________________________
 326
 327 Int_t
 328 AliT0Parameters::GetChannel(Int_t trm,  Int_t tdc, Int_t chain, Int_t channel)
 329 {
 330
 331
 332   AliT0LookUpKey * lookkey;  //= new AliT0LookUpKey();
 333   AliT0LookUpValue * lookvalue= new AliT0LookUpValue(trm,tdc,chain,channel);
 334
 335    lookkey = (AliT0LookUpKey*) fgLookUp->GetMapLookup()->GetValue((TObject*)lookvalue);
 336   if (!lookkey ) {
 337     cout<<" no such address "<<endl; return -1;
 338   }
 339
 340
 341   //cout<<"AliT0Parameters:: key "<<lookkey->GetKey()<<endl;
 342   return lookkey->GetKey();
 343
 344
 345 }