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 "AliT0LookUpValue.h"
  34 #include "AliT0LookUpKey.h"
  35 #include <AliCDBManager.h>
  36 #include <AliCDBEntry.h>
  37 #include <TMath.h>
  38 #include <TGeoManager.h>
  39 #include <TGeoPhysicalNode.h>
  40 #include <AliGeomManager.h>
  41 #include <TGeoMatrix.h>
  42
  43 AliT0CalibTimeEq* AliT0Parameters::fgCalibData = 0;
  44 AliT0CalibData* AliT0Parameters::fgLookUp = 0;
  45 AliT0CalibWalk* AliT0Parameters::fgSlewCorr =0;
  46 //====================================================================
  47 ClassImp(AliT0Parameters)
  48 #if 0
  49   ; // This is here to keep Emacs for indenting the next line
  50 #endif
  51
  52 //____________________________________________________________________
  53 AliT0Parameters* AliT0Parameters::fgInstance = 0;
  54 //____________________________________________________________________
  55 AliT0Parameters* AliT0Parameters::Instance()
  56 {
  57   // Get static instance
  58   if (!fgInstance) {
  59     fgInstance = new AliT0Parameters;
  60   }
  61   return fgInstance;
  62 }
  63
  64 //____________________________________________________________________
  65 AliT0Parameters::AliT0Parameters()
  66   :fIsInit(kFALSE),
  67    fPh2Mip(0),fmV2Mip(0),
  68    fChannelWidth(0),fmV2Channel(0),
  69    fQTmin(0),fQTmax(0),
  70    fAmpLEDRec(0),
  71    fPMTeff(),
  72    fWalk(0),
  73    fTimeDelayCFD(0),
  74  //  fTimeV0(0),
  75    fTimeDelayTVD(0),
  76    fMeanT0(512),
  77    fLookUp(0),
  78    fNumberOfTRMs(2),
  79    fCalibentry(), fLookUpentry(),fSlewCorr()
  80
  81
  82 {
  83   // Default constructor
  84   for (Int_t ipmt=0; ipmt<24; ipmt++)
  85     {
  86       SetPh2Mip();
  87       SetmV2Mip();
  88       SetChannelWidth();
  89       SetmV2channel();
  90       SetQTmin();
  91       SetQTmax();
  92       SetPMTeff(ipmt);
  93     }
  94   SetTimeDelayTVD();
  95   SetZposition();
  96
  97 }
  98
  99 //__________________________________________________________________
 100 void
 101 AliT0Parameters::Init()
 102 {
 103   // Initialize the parameters manager.  We need to get stuff from the
 104   // CDB here.
 105    if (fIsInit) return;
 106
 107    AliCDBManager *stor =AliCDBManager::Instance();
 108    //time equalizing
 109    fCalibentry  = stor->Get("T0/Calib/TimeDelay");
 110    if (fCalibentry)
 111      fgCalibData  = (AliT0CalibTimeEq*)fCalibentry->GetObject();
 112    else {
 113          AliFatal(" ALARM !!!! No time delays in CDB ");
 114      fIsInit = kFALSE;
 115      return;
 116    }
 117  //slewing correction
 118   fSlewCorr  = stor->Get("T0/Calib/Slewing_Walk");
 119   if (fSlewCorr){
 120     fgSlewCorr  = (AliT0CalibWalk*)fSlewCorr->GetObject();
 121   }
 122   else {
 123       AliFatal(" ALARM !!!! No slewing correction in CDB ");
 124     fIsInit = kFALSE;
 125     return;
 126   }
 127   //lookup table
 128   fLookUpentry  = stor->Get("T0/Calib/LookUp_Table");
 129   if (fLookUpentry){
 130     fgLookUp  = (AliT0CalibData*)fLookUpentry->GetObject();
 131   }
 132   else {
 133      AliFatal(" ALARM !!!! No Lookup table  in CDB ");
 134     fIsInit = kFALSE;
 135     return;
 136   }
 137   fIsInit = kTRUE;
 138 }
 139
 140
 141 //__________________________________________________________________
 142
 143 void AliT0Parameters::InitIfOnline()
 144 {
 145 // should be used in online
 146 // for switching to this one should write
 147   // AliT0RawReader myrawreader(rawReader);
 148 //      myrawreader.SetOnlineMode(kTRUE);
 149
 150  if (fIsInit) return;
 151    //standart configuration (used for simulation)
 152    //Int_t trm=0; Int_t tdc=0; Int_t chain=0; Int_t channel=0;
 153   // configuration for test Jun07.
 154    fgLookUp = new AliT0CalibData("T0");
 155
 156   fNumberOfTRMs = 1;
 157  fgLookUp-> SetNumberOfTRMs(fNumberOfTRMs);
 158   Int_t trm=7; Int_t tdc=0; Int_t chain=0; Int_t channel=0;
 159   for (Int_t ik=0; ik<105; ik++)
 160         {
 161          AliT0LookUpKey * lookkey= new AliT0LookUpKey();
 162          AliT0LookUpValue * lookvalue= new AliT0LookUpValue();
 163
 164
 165           lookvalue->SetTRM(trm);
 166           lookvalue->SetTDC(tdc);
 167           lookvalue->SetChain(chain);
 168           lookvalue->SetChannel(channel);
 169           lookkey->SetKey(ik);
 170           if (channel<6) channel +=2;
 171           else {channel = 0; tdc++;}
 172           if(ik==57) { tdc=0; channel=0; chain = 1;}
 173
 174           fgLookUp->GetMapLookup()->Add((TObject*)lookvalue,(TObject*)lookkey);
 175        }
 176
 177   fIsInit=kTRUE;
 178 }
 179 //__________________________________________________________________
 180 Float_t
 181 AliT0Parameters::GetTimeDelayCFD(Int_t ipmt)
 182   {
 183   // return time delay for CFD channel
 184    //
 185   if (!fCalibentry)
 186     {
 187       fTimeDelayCFD = 1000+ipmt*100;
 188       return fTimeDelayCFD;
 189     }
 190
 191   return fgCalibData->GetTimeEq(ipmt);
 192 }
 193 //__________________________________________________________________
 194
 195 TGraph *AliT0Parameters::GetAmpLEDRec(Int_t ipmt) const
 196 {
 197  // get walk correction by LED-CFD vs CFD graph
 198    if (!fSlewCorr) {
 199      AliError("No slewing correction is available!");
 200      return  (TGraph*)fAmpLEDRec.At(ipmt);
 201   }
 202   return fgSlewCorr -> GetAmpLEDRec(ipmt) ;
 203 }
 204
 205 //__________________________________________________________________
 206
 207 TGraph *AliT0Parameters::GetWalk(Int_t ipmt) const
 208 {
 209   // get walk correction by QTC vs CFD
 210   if (!fSlewCorr) {
 211     AliError("No walk correction is available!");
 212     return  (TGraph*)fWalk.At(ipmt);
 213   }
 214   return fgSlewCorr -> GetWalk(ipmt) ;
 215 }
 216
 217 //__________________________________________________________________
 218
 219 Float_t AliT0Parameters::GetWalkVal(Int_t ipmt, Float_t mv) const
 220 {
 221  // get walk correction by QTC vs CFD
 222    if (!fSlewCorr) {
 223     return ((TGraph*)fWalk.At(ipmt))->Eval(mv);
 224   }
 225   return fgSlewCorr -> GetWalkVal(ipmt, mv) ;
 226 }
 227
 228
 229 //__________________________________________________________________
 230 void
 231 AliT0Parameters::SetPMTeff(Int_t ipmt)
 232 {
 233   // PMT quantum efficiency
 234   Float_t lambda[50];
 235   Float_t eff[50 ] = {0,        0,       0.23619,  0.202909, 0.177913,
 236                     0.175667, 0.17856, 0.190769, 0.206667, 0.230286,
 237                     0.252276, 0.256267,0.26,     0.27125,  0.281818,
 238                     0.288118, 0.294057,0.296222, 0.301622, 0.290421,
 239                     0.276615, 0.2666,  0.248,    0.23619,  0.227814,
 240                     0.219818, 0.206667,0.194087, 0.184681, 0.167917,
 241                     0.154367, 0.1364,  0.109412, 0.0834615,0.0725283,
 242                     0.0642963,0.05861, 0.0465,   0.0413333,0.032069,
 243                     0.0252203,0.02066, 0.016262, 0.012,    0.00590476,
 244                     0.003875, 0.00190, 0,        0,        0          } ;
 245   for (Int_t i=0; i<50; i++) lambda[i]=200+10*i;
 246
 247   TGraph* gr = new TGraph(50,lambda,eff);
 248   fPMTeff.AddAtAndExpand(gr,ipmt);
 249 }
 250 //________________________________________________________________
 251
 252 Int_t
 253 AliT0Parameters::GetChannel(Int_t trm,  Int_t tdc, Int_t chain, Int_t channel)
 254 {
 255     // get logical number of channel according physical address
 256
 257   if (fgLookUp) {
 258     AliT0LookUpValue key(trm,tdc,chain,channel);
 259       AliT0LookUpKey *val = (AliT0LookUpKey*) fgLookUp->GetMapLookup()->GetValue((TObject*)&key);
 260       // AliT0LookUpKey *val = (AliT0LookUpKey*) fLookUp.GetValue((TObject*)&key);
 261     if (val )
 262       return val->GetKey();
 263     else {
 264       AliWarning(Form("No such address (%d %d %d %d)!",trm,tdc,chain,channel));
 265       return -1;
 266     }
 267   }
 268   else {
 269     AliError("No look up table has been loader!");
 270     return -1;
 271   }
 272
 273 }
 274 //__________________________________________________________________
 275 TMap *AliT0Parameters::GetMapLookup()
 276 {
 277   // get LookUp Table
 278
 279   if (!fgLookUp){
 280     cout<<" No look up table in OCDB";
 281     return 0;
 282   }
 283   return   fgLookUp->GetMapLookup();
 284 }
 285 //__________________________________________________________________
 286
 287 Int_t
 288 AliT0Parameters::GetNumberOfTRMs()
 289 {
 290   // return number of trms
 291   //
 292   if (!fgLookUp) {
 293     //  fNumberOfTRMs = 2;
 294     return  fNumberOfTRMs;
 295   }
 296   return  fgLookUp ->GetNumberOfTRMs();
 297 }
 298 /*
 299 //________________________________________________________________________________
 300 Double_t AliT0Parameters::GetZPosition(const char* symname){
 301 // Get the global z coordinate of the given T0 alignable volume
 302 //
 303   Double_t *tr = AliGeomManager::GetMatrix(symname)->GetTranslation();
 304
 305   return tr[2];
 306 }
 307 */
 308 //________________________________________________________________________________
 309 Double_t AliT0Parameters::GetZPosition(const char* symname){
 310 // Get the global z coordinate of the given T0 alignable volume
 311 //
 312   Double_t *tr;
 313   TGeoPNEntry *pne = gGeoManager->GetAlignableEntry(symname);
 314   if (!pne) return 0;
 315
 316
 317   TGeoPhysicalNode *pnode = pne->GetPhysicalNode();
 318   if(pnode){
 319           TGeoHMatrix* hm = pnode->GetMatrix();
 320            tr = hm->GetTranslation();
 321   }else{
 322           const char* path = pne->GetTitle();
 323           if(!gGeoManager->cd(path)){
 324                   AliErrorClass(Form("Volume path %s not valid!",path));
 325                   return 0;
 326           }
 327          tr = gGeoManager->GetCurrentMatrix()->GetTranslation();
 328   }
 329   return tr[2];
 330
 331 }
 332 //________________________________________________________________________________
 333
 334 Double_t AliT0Parameters::GetZPositionShift(const char* symname)
 335 {
 336 // Get the global z coordinate of the given T0 alignable volume
 337 //
 338   Double_t *tr = AliGeomManager::GetMatrix(symname)->GetTranslation();
 339
 340   TGeoHMatrix origmat;
 341   AliGeomManager::GetOrigGlobalMatrix(symname,origmat);
 342   Double_t *otr = origmat.GetTranslation();
 343
 344   return (tr[2]-otr[2]);
 345 }
 346