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