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