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 Float_t
 233 AliT0Parameters::GetCFD(Int_t ipmt)
 234   {
 235   // return  CFD channel
 236
 237     return fgCalibData->GetCFDvalue(ipmt,0);
 238 }
 239
 240 //__________________________________________________________________
 241 Float_t
 242 AliT0Parameters::GetLatencyHPTDC()
 243   {
 244   // return LatencyHPTDC for CFD channel
 245   if (!fLatency)
 246     {
 247       fLatencyHPTDC=9000.;
 248       return fLatencyHPTDC;
 249     }
 250
 251   return fgLatency->GetLatencyHPTDC();
 252 }
 253 //__________________________________________________________________
 254 Float_t
 255 AliT0Parameters::GetLatencyL1()
 256   {
 257   // return time delay for CFD channel
 258
 259   return fgLatency->GetLatencyL1();
 260 }
 261
 262 //__________________________________________________________________
 263 Float_t
 264 AliT0Parameters::GetLatencyL1A()
 265   {
 266   // return time delay for CFD channel
 267
 268   return fgLatency->GetLatencyL1A();
 269 }
 270
 271 //__________________________________________________________________
 272 Float_t
 273 AliT0Parameters::GetLatencyL1C()
 274   {
 275   // return time delay for CFD channel
 276
 277   return fgLatency->GetLatencyL1C();
 278 }
 279 //__________________________________________________________________
 280
 281 Float_t
 282 AliT0Parameters:: GetMeanVertex()
 283 {
 284   if (!fCalibentry)
 285     {
 286       fMeanVertex=0;
 287       return fMeanVertex;
 288     }
 289
 290   return fgCalibData->GetMeanVertex();
 291 }
 292 //__________________________________________________________________
 293
 294 TGraph *AliT0Parameters::GetAmpLEDRec(Int_t ipmt) const
 295 {
 296    if (!fSlewCorr) {
 297      AliError("No slewing correction is available!");
 298      return  (TGraph*)fAmpLEDRec.At(ipmt);
 299   }
 300   return fgSlewCorr -> GetAmpLEDRec(ipmt) ;
 301 }
 302
 303 //__________________________________________________________________
 304
 305 TGraph *AliT0Parameters::GetWalk(Int_t ipmt) const
 306 {
 307   if (!fSlewCorr) {
 308     AliError("No walk correction is available!");
 309     return  (TGraph*)fWalk.At(ipmt);
 310   }
 311   return fgSlewCorr -> GetWalk(ipmt) ;
 312 }
 313
 314 //__________________________________________________________________
 315
 316 TGraph *AliT0Parameters::GetQTC(Int_t ipmt) const
 317 {
 318   if (!fSlewCorr) {
 319     AliError("No walk correction is available!");
 320     //    return  (TGraph*)fQTC.At(ipmt);
 321    return  0;
 322   }
 323   return fgSlewCorr -> GetQTC(ipmt) ;
 324 }
 325
 326 //__________________________________________________________________
 327 TGraph *AliT0Parameters::GetAmpLED(Int_t ipmt) const
 328 {
 329   if (!fSlewCorr) {
 330     AliError("No walk correction is available!");
 331     //    return  (TGraph*)fQTC.At(ipmt);
 332    return  0;
 333   }
 334   return fgSlewCorr -> GetAmpLED(ipmt) ;
 335 }
 336
 337 //__________________________________________________________________
 338 void
 339 AliT0Parameters::SetPMTeff(Int_t ipmt)
 340 {
 341   Float_t lambda[50];
 342   Float_t eff[50 ] = {0,        0,       0.23619,  0.202909, 0.177913,
 343                     0.175667, 0.17856, 0.190769, 0.206667, 0.230286,
 344                     0.252276, 0.256267,0.26,     0.27125,  0.281818,
 345                     0.288118, 0.294057,0.296222, 0.301622, 0.290421,
 346                     0.276615, 0.2666,  0.248,    0.23619,  0.227814,
 347                     0.219818, 0.206667,0.194087, 0.184681, 0.167917,
 348                     0.154367, 0.1364,  0.109412, 0.0834615,0.0725283,
 349                     0.0642963,0.05861, 0.0465,   0.0413333,0.032069,
 350                     0.0252203,0.02066, 0.016262, 0.012,    0.00590476,
 351                     0.003875, 0.00190, 0,        0,        0          } ;
 352   for (Int_t i=0; i<50; i++) lambda[i]=200+10*i;
 353
 354   TGraph* gr = new TGraph(50,lambda,eff);
 355   fPMTeff.AddAtAndExpand(gr,ipmt);
 356 }
 357 //________________________________________________________________
 358
 359 Int_t
 360 AliT0Parameters::GetChannel(Int_t trm,  Int_t tdc, Int_t chain, Int_t channel)
 361 {
 362
 363   if (fgLookUp) {
 364     AliT0LookUpValue key(trm,tdc,chain,channel);
 365       AliT0LookUpKey *val = (AliT0LookUpKey*) fgLookUp->GetMapLookup()->GetValue((TObject*)&key);
 366       // AliT0LookUpKey *val = (AliT0LookUpKey*) fLookUp.GetValue((TObject*)&key);
 367     if (val )
 368       return val->GetKey();
 369     else {
 370       AliWarning(Form("No such address (%d %d %d %d)!",trm,tdc,chain,channel));
 371       return -1;
 372     }
 373   }
 374   else {
 375     AliError("No look up table has been loader!");
 376     return -1;
 377   }
 378
 379 }
 380 //__________________________________________________________________
 381 TMap *AliT0Parameters::GetMapLookup()
 382 {
 383   if (!fgLookUp){
 384     cout<<" No look up table in OCDB";
 385     return 0;
 386   }
 387   return   fgLookUp->GetMapLookup();
 388 }
 389 //__________________________________________________________________
 390
 391 Int_t
 392 AliT0Parameters::GetNumberOfTRMs()
 393 {
 394   // return number of trms
 395   //
 396   if (!fgLookUp) {
 397     //  fNumberOfTRMs = 2;
 398     return  fNumberOfTRMs;
 399   }
 400   return  fgLookUp ->GetNumberOfTRMs();
 401 }
 402 /*
 403 //________________________________________________________________________________
 404 Double_t AliT0Parameters::GetZPosition(const char* symname){
 405 // Get the global z coordinate of the given T0 alignable volume
 406 //
 407   Double_t *tr = AliGeomManager::GetMatrix(symname)->GetTranslation();
 408
 409   return tr[2];
 410 }
 411 */
 412 //________________________________________________________________________________
 413 Double_t AliT0Parameters::GetZPosition(const char* symname){
 414 // Get the global z coordinate of the given T0 alignable volume
 415 //
 416   Double_t *tr;
 417   TGeoPNEntry *pne = gGeoManager->GetAlignableEntry(symname);
 418   if (!pne) return 0;
 419
 420
 421   TGeoPhysicalNode *pnode = pne->GetPhysicalNode();
 422   if(pnode){
 423           TGeoHMatrix* hm = pnode->GetMatrix();
 424            tr = hm->GetTranslation();
 425   }else{
 426           const char* path = pne->GetTitle();
 427           if(!gGeoManager->cd(path)){
 428                   AliErrorClass(Form("Volume path %s not valid!",path));
 429                   return 0;
 430           }
 431          tr = gGeoManager->GetCurrentMatrix()->GetTranslation();
 432   }
 433   return tr[2];
 434
 435 }
 436 //________________________________________________________________________________
 437
 438 Double_t AliT0Parameters::GetZPositionShift(const char* symname)
 439 {
 440 // Get the global z coordinate of the given T0 alignable volume
 441 //
 442   Double_t *tr = AliGeomManager::GetMatrix(symname)->GetTranslation();
 443
 444   TGeoHMatrix origmat;
 445   AliGeomManager::GetOrigGlobalMatrix(symname,origmat);
 446   Double_t *otr = origmat.GetTranslation();
 447
 448   return (tr[2]-otr[2]);
 449 }
 450