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