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