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 "AliT0.h"
  28 #include "AliLog.h"
  29 #include "AliT0Parameters.h"
  30 #include "AliT0CalibData.h"
  31 #include "AliT0CalibWalk.h"
  32 #include "AliT0CalibTimeEq.h"
  33 #include "AliT0CalibLatency.h"
  34 #include "AliT0LookUpKey.h"
  35 #include "AliT0LookUpValue.h"
  36 #include <AliCDBManager.h>
  37 #include <AliCDBEntry.h>
  38 #include <AliCDBStorage.h>
  39 #include <TMath.h>
  40 #include <TSystem.h>
  41 //#include <Riostream.h>
  42 #include <TGeoManager.h>
  43 #include <TGeoPhysicalNode.h>
  44 #include <TGeoMatrix.h>
  45 #include <AliGeomManager.h>
  46
  47 AliT0CalibTimeEq* AliT0Parameters::fgCalibData = 0;
  48 AliT0CalibData* AliT0Parameters::fgLookUp = 0;
  49 AliT0CalibWalk* AliT0Parameters::fgSlewCorr =0;
  50 AliT0CalibLatency *AliT0Parameters::fgLatency=0;
  51 //====================================================================
  52 using std::cout;
  53 ClassImp(AliT0Parameters)
  54 #if 0
  55   ; // This is here to keep Emacs for indenting the next line
  56 #endif
  57
  58 //____________________________________________________________________
  59 AliT0Parameters* AliT0Parameters::fgInstance = 0;
  60 //____________________________________________________________________
  61 AliT0Parameters* AliT0Parameters::Instance()
  62 {
  63   // Get static instance
  64   if (!fgInstance) {
  65     fgInstance = new AliT0Parameters;
  66   }
  67   return fgInstance;
  68 }
  69
  70 //____________________________________________________________________
  71 AliT0Parameters::AliT0Parameters()
  72   :fIsInit(kFALSE),
  73    fPh2Mip(0),fmV2Mip(0),
  74    fChannelWidth(0),fmV2Channel(0),
  75    fQTmin(0),fQTmax(0),
  76    fAmpLEDRec(0),
  77    fPMTeff(),
  78    fWalk(0),
  79    fQTC(0),
  80    fAmpLED(0),
  81    fTimeDelayCFD(0),
  82  //  fTimeV0(0),
  83    fTimeDelayTVD(0),
  84    fMeanT0(512),
  85    fMeanVertex(0),
  86    fLatencyHPTDC(0),
  87    fLatencyL1(0),
  88    fLatencyL1A(0),
  89    fLatencyL1C(0),
  90    fLookUp(0),
  91    fNumberOfTRMs(2),
  92    fCalibentry(),
  93    fLookUpentry(),
  94    fSlewCorr(),
  95    fLatency()
  96
  97 {
  98   // Default constructor
  99   for (Int_t ipmt=0; ipmt<24; ipmt++)
 100     {
 101       SetPh2Mip();
 102       SetmV2Mip();
 103       SetChannelWidth();
 104       SetmV2channel();
 105       SetQTmin();
 106       SetQTmax();
 107       SetPMTeff(ipmt);
 108     }
 109   SetTimeDelayTVD();
 110   SetZposition();
 111
 112 }
 113
 114 //__________________________________________________________________
 115 void
 116 AliT0Parameters::Init()
 117 {
 118   // Initialize the parameters manager.  We need to get stuff from the
 119   // CDB here.
 120    if (fIsInit) return;
 121
 122    AliCDBManager *stor =AliCDBManager::Instance();
 123    //time equalizing
 124    fCalibentry  = stor->Get("T0/Calib/TimeDelay");
 125    if (fCalibentry)
 126      fgCalibData  = (AliT0CalibTimeEq*)fCalibentry->GetObject();
 127    else {
 128          AliFatal(" ALARM !!!! No time delays in CDB ");
 129      fIsInit = kFALSE;
 130      return;
 131    }
 132  //slewing correction
 133   fSlewCorr  = stor->Get("T0/Calib/Slewing_Walk");
 134   if (fSlewCorr){
 135     fgSlewCorr  = (AliT0CalibWalk*)fSlewCorr->GetObject();
 136   }
 137   else {
 138       AliFatal(" ALARM !!!! No slewing correction in CDB ");
 139     fIsInit = kFALSE;
 140     return;
 141   }
 142   //lookup table
 143   fLookUpentry  = stor->Get("T0/Calib/LookUp_Table");
 144   if (fLookUpentry){
 145     fgLookUp  = (AliT0CalibData*)fLookUpentry->GetObject();
 146   }
 147   else {
 148      AliFatal(" ALARM !!!! No Lookup table  in CDB ");
 149     fIsInit = kFALSE;
 150     return;
 151   }
 152   //latency
 153
 154  fLatency  = stor->Get("T0/Calib/Latency");
 155   if (fLatency){
 156     fgLatency  = (AliT0CalibLatency*)fLatency->GetObject();
 157   }
 158   else {
 159      AliWarning(" !!! no latency  in CDB ");
 160     return;
 161   }
 162
 163 fIsInit = kTRUE;
 164 }
 165
 166
 167 //__________________________________________________________________
 168
 169 void AliT0Parameters::InitIfOnline()
 170 {
 171 // should be used in online
 172 // for switching to this one should write
 173   // AliT0RawReader myrawreader(rawReader);
 174 //      myrawreader.SetOnlineMode(kTRUE);
 175
 176   if (fIsInit) return;
 177   //standart configuration (used for simulation)
 178   //Int_t trm=0; Int_t tdc=0; Int_t chain=0; Int_t channel=0;
 179   // configuration for test Jun07.
 180   fgLookUp = new AliT0CalibData("T0");
 181
 182   fNumberOfTRMs = 1;
 183   fgLookUp-> SetNumberOfTRMs(fNumberOfTRMs);
 184   Int_t trm=7; Int_t tdc=0; Int_t chain=0; Int_t channel=0;
 185   for (Int_t ik=0; ik<105; ik++)
 186     {
 187       AliT0LookUpKey * lookkey= new AliT0LookUpKey();
 188       AliT0LookUpValue * lookvalue= new AliT0LookUpValue();
 189       lookvalue->SetTRM(trm);
 190       lookvalue->SetTDC(tdc);
 191       lookvalue->SetChain(chain);
 192       lookvalue->SetChannel(channel);
 193       lookkey->SetKey(ik);
 194       fgLookUp->GetMapLookup()->Add((TObject*)lookvalue,(TObject*)lookkey);
 195       if (channel<6) channel +=2;
 196       else {channel = 0; tdc++;}
 197       if(ik==56) { tdc=0; channel=0; chain = 1;}
 198     }
 199   //2 recent open channels
 200   trm=7; tdc=14; channel=2; chain=0;
 201   for (Int_t ik=105; ik<107; ik++)
 202     {
 203       AliT0LookUpKey * lookkey= new AliT0LookUpKey();
 204       AliT0LookUpValue * lookvalue= new AliT0LookUpValue();
 205
 206       lookvalue->SetTRM(trm);
 207       lookvalue->SetTDC(tdc);
 208       lookvalue->SetChain(chain);
 209       lookvalue->SetChannel(channel);
 210       lookkey->SetKey(ik);
 211       fgLookUp->GetMapLookup()->Add((TObject*)lookvalue,(TObject*)lookkey);
 212       if (channel<6) channel +=2;
 213       else {channel = 0; tdc++;}
 214     }
 215
 216   fIsInit=kTRUE;
 217 }
 218 //__________________________________________________________________
 219 Float_t
 220 AliT0Parameters::GetTimeDelayCFD(Int_t ipmt)
 221   {
 222   // return time delay for CFD channel
 223    //
 224   if (!fCalibentry)
 225     {
 226       fTimeDelayCFD = 1000+ipmt*100;
 227       return fTimeDelayCFD;
 228     }
 229
 230   return fgCalibData->GetTimeEq(ipmt);
 231 }
 232 //__________________________________________________________________
 233 Float_t
 234 AliT0Parameters::GetCFD(Int_t ipmt)
 235   {
 236   // return  CFD channel
 237
 238     return fgCalibData->GetCFDvalue(ipmt,0);
 239 }
 240
 241 //__________________________________________________________________
 242 Float_t
 243 AliT0Parameters::GetLatencyHPTDC()
 244   {
 245   // return LatencyHPTDC for CFD channel
 246   if (!fLatency)
 247     {
 248       fLatencyHPTDC=9000.;
 249       return fLatencyHPTDC;
 250     }
 251
 252   return fgLatency->GetLatencyHPTDC();
 253 }
 254 //__________________________________________________________________
 255 Float_t
 256 AliT0Parameters::GetLatencyL1()
 257   {
 258   // return time delay for CFD channel
 259
 260   return fgLatency->GetLatencyL1();
 261 }
 262
 263 //__________________________________________________________________
 264 Float_t
 265 AliT0Parameters::GetLatencyL1A()
 266   {
 267   // return time delay for CFD channel
 268
 269   return fgLatency->GetLatencyL1A();
 270 }
 271
 272 //__________________________________________________________________
 273 Float_t
 274 AliT0Parameters::GetLatencyL1C()
 275   {
 276   // return time delay for CFD channel
 277
 278   return fgLatency->GetLatencyL1C();
 279 }
 280 //__________________________________________________________________
 281
 282 Float_t
 283 AliT0Parameters:: GetMeanVertex()
 284 {
 285   if (!fCalibentry)
 286     {
 287       fMeanVertex=0;
 288       return fMeanVertex;
 289     }
 290
 291   return fgCalibData->GetMeanVertex();
 292 }
 293 //__________________________________________________________________
 294
 295 TGraph *AliT0Parameters::GetAmpLEDRec(Int_t ipmt) const
 296 {
 297    if (!fSlewCorr) {
 298      AliError("No slewing correction is available!");
 299      return  (TGraph*)fAmpLEDRec.At(ipmt);
 300   }
 301   return fgSlewCorr -> GetAmpLEDRec(ipmt) ;
 302 }
 303
 304 //__________________________________________________________________
 305
 306 TGraph *AliT0Parameters::GetWalk(Int_t ipmt) const
 307 {
 308   if (!fSlewCorr) {
 309     AliError("No walk correction is available!");
 310     return  (TGraph*)fWalk.At(ipmt);
 311   }
 312   return fgSlewCorr -> GetWalk(ipmt) ;
 313 }
 314
 315 //__________________________________________________________________
 316
 317 TGraph *AliT0Parameters::GetQTC(Int_t ipmt) const
 318 {
 319   if (!fSlewCorr) {
 320     AliError("No walk correction is available!");
 321     //    return  (TGraph*)fQTC.At(ipmt);
 322    return  0;
 323   }
 324   return fgSlewCorr -> GetQTC(ipmt) ;
 325 }
 326
 327 //__________________________________________________________________
 328 TGraph *AliT0Parameters::GetAmpLED(Int_t ipmt) const
 329 {
 330   if (!fSlewCorr) {
 331     AliError("No walk correction is available!");
 332     //    return  (TGraph*)fQTC.At(ipmt);
 333    return  0;
 334   }
 335   return fgSlewCorr -> GetAmpLED(ipmt) ;
 336 }
 337
 338 //__________________________________________________________________
 339 void
 340 AliT0Parameters::SetPMTeff(Int_t ipmt)
 341 {
 342   Float_t lambda[50];
 343   Float_t eff[50 ] = {0,        0,       0.23619,  0.202909, 0.177913,
 344                     0.175667, 0.17856, 0.190769, 0.206667, 0.230286,
 345                     0.252276, 0.256267,0.26,     0.27125,  0.281818,
 346                     0.288118, 0.294057,0.296222, 0.301622, 0.290421,
 347                     0.276615, 0.2666,  0.248,    0.23619,  0.227814,
 348                     0.219818, 0.206667,0.194087, 0.184681, 0.167917,
 349                     0.154367, 0.1364,  0.109412, 0.0834615,0.0725283,
 350                     0.0642963,0.05861, 0.0465,   0.0413333,0.032069,
 351                     0.0252203,0.02066, 0.016262, 0.012,    0.00590476,
 352                     0.003875, 0.00190, 0,        0,        0          } ;
 353   for (Int_t i=0; i<50; i++) lambda[i]=200+10*i;
 354
 355   TGraph* gr = new TGraph(50,lambda,eff);
 356   fPMTeff.AddAtAndExpand(gr,ipmt);
 357 }
 358 //________________________________________________________________
 359
 360 Int_t
 361 AliT0Parameters::GetChannel(Int_t trm,  Int_t tdc, Int_t chain, Int_t channel)
 362 {
 363
 364   if (fgLookUp) {
 365     AliT0LookUpValue key(trm,tdc,chain,channel);
 366       AliT0LookUpKey *val = (AliT0LookUpKey*) fgLookUp->GetMapLookup()->GetValue((TObject*)&key);
 367       // AliT0LookUpKey *val = (AliT0LookUpKey*) fLookUp.GetValue((TObject*)&key);
 368     if (val )
 369       return val->GetKey();
 370     else {
 371       AliWarning(Form("No such address (%d %d %d %d)!",trm,tdc,chain,channel));
 372       return -1;
 373     }
 374   }
 375   else {
 376     AliError("No look up table has been loader!");
 377     return -1;
 378   }
 379
 380 }
 381 //__________________________________________________________________
 382 TMap *AliT0Parameters::GetMapLookup()
 383 {
 384   if (!fgLookUp){
 385     cout<<" No look up table in OCDB";
 386     return 0;
 387   }
 388   return   fgLookUp->GetMapLookup();
 389 }
 390 //__________________________________________________________________
 391
 392 Int_t
 393 AliT0Parameters::GetNumberOfTRMs()
 394 {
 395   // return number of trms
 396   //
 397   if (!fgLookUp) {
 398     //  fNumberOfTRMs = 2;
 399     return  fNumberOfTRMs;
 400   }
 401   return  fgLookUp ->GetNumberOfTRMs();
 402 }
 403 /*
 404 //________________________________________________________________________________
 405 Double_t AliT0Parameters::GetZPosition(const char* symname){
 406 // Get the global z coordinate of the given T0 alignable volume
 407 //
 408   Double_t *tr = AliGeomManager::GetMatrix(symname)->GetTranslation();
 409
 410   return tr[2];
 411 }
 412 */
 413 //________________________________________________________________________________
 414 Double_t AliT0Parameters::GetZPosition(const char* symname){
 415 // Get the global z coordinate of the given T0 alignable volume
 416 //
 417   Double_t *tr;
 418   TGeoPNEntry *pne = gGeoManager->GetAlignableEntry(symname);
 419   if (!pne) return 0;
 420
 421
 422   TGeoPhysicalNode *pnode = pne->GetPhysicalNode();
 423   if(pnode){
 424           TGeoHMatrix* hm = pnode->GetMatrix();
 425            tr = hm->GetTranslation();
 426   }else{
 427           const char* path = pne->GetTitle();
 428           if(!gGeoManager->cd(path)){
 429                   AliErrorClass(Form("Volume path %s not valid!",path));
 430                   return 0;
 431           }
 432          tr = gGeoManager->GetCurrentMatrix()->GetTranslation();
 433   }
 434   return tr[2];
 435
 436 }
 437 //________________________________________________________________________________
 438
 439 Double_t AliT0Parameters::GetZPositionShift(const char* symname)
 440 {
 441 // Get the global z coordinate of the given T0 alignable volume
 442 //
 443   Double_t *tr = AliGeomManager::GetMatrix(symname)->GetTranslation();
 444
 445   TGeoHMatrix origmat;
 446   AliGeomManager::GetOrigGlobalMatrix(symname,origmat);
 447   Double_t *otr = origmat.GetTranslation();
 448
 449   return (tr[2]-otr[2]);
 450 }
 451