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
  92   AliCDBStorage *stor =AliCDBManager::Instance()->GetStorage("local://$ALICE_ROOT");
  93   //time equalizing
  94   AliCDBEntry* fCalibentry  = stor->Get("T0/Calib/TimeDelay",0);
  95  if (fCalibentry){
  96    fgCalibData  = (AliT0CalibData*)fCalibentry->GetObject();
  97   }
  98  else
  99    { AliError(" ALARM !!!! No time delays in CDB "); }
 100  //slewing correction
 101   AliCDBEntry* fSlewCorr  = stor->Get("T0/Calib/Slewing_Walk",0);
 102  if (fSlewCorr){
 103    fgSlewCorr  = (AliT0CalibData*)fSlewCorr->GetObject();
 104   }
 105   fLookUpentry  = stor->Get("T0/Calib/LookUp_Table",0);
 106   if (fLookUpentry){
 107     fgLookUp  = (AliT0CalibData*)fLookUpentry->GetObject();
 108   }
 109   else {
 110   const char * filename = gSystem->ExpandPathName("$ALICE_ROOT/T0/lookUpTable.txt");
 111   ifstream inFile(filename);
 112   fgLookUp->ReadAsciiLookup(filename);
 113   }
 114
 115   fIsInit = kTRUE;
 116 }
 117
 118
 119 //__________________________________________________________________
 120 Float_t
 121 AliT0Parameters::GetTimeDelayLED(Int_t ipmt)
 122 {
 123   // return time delay for LED channel
 124   //
 125   if (!fCalibentry) {
 126     fTimeDelayLED = 0;
 127     return  fTimeDelayLED;
 128   }
 129   return fgCalibData ->GetTimeDelayLED(ipmt);
 130 }
 131 //__________________________________________________________________
 132 Float_t
 133 AliT0Parameters::GetTimeDelayCFD(Int_t ipmt)
 134 {
 135   // return time delay for CFD channel
 136    //
 137   if (!fCalibentry)
 138     {
 139       fTimeDelayCFD = 1000+ipmt*100;
 140       return fTimeDelayCFD;
 141     }
 142
 143   return fgCalibData->GetTimeDelayCFD(ipmt);
 144 }
 145
 146 //__________________________________________________________________
 147
 148 void
 149 AliT0Parameters::SetSlewingLED(Int_t ipmt)
 150 {
 151   //  Set Slweing Correction for LED channel
 152      Float_t mv[23] = {25, 30,40,60, 80,100,150,200,250,300,
 153                        400,500,600,800,1000,1500, 2000, 3000, 4000, 5500,
 154                        6000, 7000,8000};
 155       Float_t y[23] = {5044, 4719, 3835, 3224, 2847, 2691,2327, 2067, 1937, 1781,
 156                        1560, 1456 ,1339, 1163.5, 1027, 819, 650, 520, 370.5, 234,
 157                        156, 78, 0};
 158
 159       TGraph* gr = new TGraph(23,mv,y);
 160       fSlewingLED.AddAtAndExpand(gr,ipmt);
 161   }
 162 //__________________________________________________________________
 163
 164 Float_t AliT0Parameters::GetSlewingLED(Int_t ipmt, Float_t mv) const
 165 {
 166   if (!fCalibentry) {
 167     return ((TGraph*)fSlewingLED.At(ipmt))->Eval(mv);
 168   }
 169   return fgCalibData->GetSlewingLED(ipmt, mv) ;
 170 }
 171
 172
 173 //__________________________________________________________________
 174
 175 TGraph *AliT0Parameters::GetSlew(Int_t ipmt) const
 176 {
 177   if (!fCalibentry) {
 178     return  (TGraph*)fSlewingLED.At(ipmt);
 179   }
 180   return fgCalibData -> GetSlew(ipmt) ;
 181 }
 182
 183 //__________________________________________________________________
 184
 185
 186 void
 187 AliT0Parameters::SetSlewingRec(Int_t ipmt)
 188 {
 189   //  Set Slweing Correction for LED channel
 190       Float_t mv[23] = {25, 30, 40,60, 80,100,150,200,250,300,
 191                         400,500,600,800,1000,1500, 2000, 3000, 4000, 5500,
 192                         6000, 7000,8000};
 193       Float_t y[23] = {5044, 4719, 3835, 3224, 2847, 2691,2327, 2067, 1937, 1781,
 194                        1560, 1456 ,1339, 1163.5, 1027, 819, 650, 520, 370.5, 234,
 195                        156, 78, 0};
 196       Float_t y1[23], mv1[23];
 197       for (Int_t i=0; i<23; i++){
 198         y1[i] = y[22-i]; mv1[i] = mv[22-i];}
 199
 200       TGraph* gr = new TGraph(23,y1,mv1);
 201       fSlewingRec.AddAtAndExpand(gr,ipmt);
 202
 203 }
 204 //__________________________________________________________________
 205
 206 Float_t AliT0Parameters::GetSlewingRec(Int_t ipmt, Float_t mv) const
 207 {
 208   if (!fCalibentry) {
 209     return ((TGraph*)fSlewingRec.At(ipmt))->Eval(mv);
 210   }
 211   return fgCalibData -> GetSlewingRec(ipmt, mv) ;
 212 }
 213
 214 //__________________________________________________________________
 215
 216 TGraph *AliT0Parameters::GetSlewRec(Int_t ipmt) const
 217 {
 218   if (!fCalibentry) {
 219     return  (TGraph*)fSlewingRec.At(ipmt);
 220   }
 221   return fgCalibData -> GetSlewRec(ipmt) ;
 222 }
 223
 224
 225 //________________________________________________________________
 226 void AliT0Parameters::SetWalk(Int_t ipmt)
 227 {
 228
 229  Int_t mv, ps;
 230   Int_t x[70000], y[70000], index[70000];
 231   Float_t time[10000],amplitude[10000];
 232   string buffer;
 233   Bool_t down=false;
 234
 235   const char * filename = gSystem->ExpandPathName("$ALICE_ROOT/T0/data/CFD-Amp.txt");
 236   ifstream inFile(filename);
 237   //  if(!inFile) AliError(Form("Cannot open file %s !",filename));
 238
 239   Int_t i=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<i; 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 }