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 "AliLog.h"
  28 #include "AliT0Parameters.h"
  29 #include "AliT0CalibData.h"
  30 #include "AliT0CalibWalk.h"
  31 #include "AliT0CalibTimeEq.h"
  32 #include "AliT0LookUpValue.h"
  33 #include <AliCDBManager.h>
  34 #include <AliCDBEntry.h>
  35 #include <AliCDBStorage.h>
  36 #include <TMath.h>
  37 #include <TSystem.h>
  38 #include <Riostream.h>
  39 #include <TGeoManager.h>
  40 #include <TGeoPhysicalNode.h>
  41 #include <AliGeomManager.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(500),
  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 Int_t
 196 AliT0Parameters::GetMeanT0()
 197 {
 198   // return mean of T0 distrubution with vertex=0
 199    //
 200   if (!fCalibentry)
 201     {
 202       return fMeanT0;
 203     }
 204
 205   return fgCalibData->GetMeanT0();
 206 }
 207 //__________________________________________________________________
 208
 209 TGraph *AliT0Parameters::GetAmpLEDRec(Int_t ipmt) const
 210 {
 211    if (!fSlewCorr) {
 212      AliError("No slewing correction is available!");
 213      return  (TGraph*)fAmpLEDRec.At(ipmt);
 214   }
 215   return fgSlewCorr -> GetAmpLEDRec(ipmt) ;
 216 }
 217
 218 //__________________________________________________________________
 219
 220 TGraph *AliT0Parameters::GetWalk(Int_t ipmt) const
 221 {
 222   if (!fSlewCorr) {
 223     AliError("No walk correction is available!");
 224     return  (TGraph*)fWalk.At(ipmt);
 225   }
 226   return fgSlewCorr -> GetWalk(ipmt) ;
 227 }
 228
 229 //__________________________________________________________________
 230
 231 Float_t AliT0Parameters::GetWalkVal(Int_t ipmt, Float_t mv) const
 232 {
 233   if (!fSlewCorr) {
 234     return ((TGraph*)fWalk.At(ipmt))->Eval(mv);
 235   }
 236   return fgSlewCorr -> GetWalkVal(ipmt, mv) ;
 237 }
 238
 239
 240 //__________________________________________________________________
 241 void
 242 AliT0Parameters::SetPMTeff(Int_t ipmt)
 243 {
 244   Float_t lambda[50];
 245   Float_t eff[50 ] = {0,        0,       0.23619,  0.202909, 0.177913,
 246                     0.175667, 0.17856, 0.190769, 0.206667, 0.230286,
 247                     0.252276, 0.256267,0.26,     0.27125,  0.281818,
 248                     0.288118, 0.294057,0.296222, 0.301622, 0.290421,
 249                     0.276615, 0.2666,  0.248,    0.23619,  0.227814,
 250                     0.219818, 0.206667,0.194087, 0.184681, 0.167917,
 251                     0.154367, 0.1364,  0.109412, 0.0834615,0.0725283,
 252                     0.0642963,0.05861, 0.0465,   0.0413333,0.032069,
 253                     0.0252203,0.02066, 0.016262, 0.012,    0.00590476,
 254                     0.003875, 0.00190, 0,        0,        0          } ;
 255   for (Int_t i=0; i<50; i++) lambda[i]=200+10*i;
 256
 257   TGraph* gr = new TGraph(50,lambda,eff);
 258   fPMTeff.AddAtAndExpand(gr,ipmt);
 259 }
 260 //________________________________________________________________
 261
 262 Int_t
 263 AliT0Parameters::GetChannel(Int_t trm,  Int_t tdc, Int_t chain, Int_t channel)
 264 {
 265
 266   if (fgLookUp) {
 267     AliT0LookUpValue key(trm,tdc,chain,channel);
 268       AliT0LookUpKey *val = (AliT0LookUpKey*) fgLookUp->GetMapLookup()->GetValue((TObject*)&key);
 269       // AliT0LookUpKey *val = (AliT0LookUpKey*) fLookUp.GetValue((TObject*)&key);
 270     if (val )
 271       return val->GetKey();
 272     else {
 273       AliWarning(Form("No such address (%d %d %d %d)!",trm,tdc,chain,channel));
 274       return -1;
 275     }
 276   }
 277   else {
 278     AliError("No look up table has been loader!");
 279     return -1;
 280   }
 281
 282 }
 283 //__________________________________________________________________
 284 TMap *AliT0Parameters::GetMapLookup()
 285 {
 286   if (!fgLookUp){
 287     cout<<" No look up table in OCDB";
 288     return 0;
 289   }
 290   return   fgLookUp->GetMapLookup();
 291 }
 292 //__________________________________________________________________
 293
 294 Int_t
 295 AliT0Parameters::GetNumberOfTRMs()
 296 {
 297   // return number of trms
 298   //
 299   if (!fgLookUp) {
 300     //  fNumberOfTRMs = 2;
 301     return  fNumberOfTRMs;
 302   }
 303   return  fgLookUp ->GetNumberOfTRMs();
 304 }
 305 /*
 306 //________________________________________________________________________________
 307 Double_t AliT0Parameters::GetZPosition(const char* symname){
 308 // Get the global z coordinate of the given T0 alignable volume
 309 //
 310   Double_t *tr = AliGeomManager::GetMatrix(symname)->GetTranslation();
 311
 312   return tr[2];
 313 }
 314 */
 315 //________________________________________________________________________________
 316 Double_t AliT0Parameters::GetZPosition(const char* symname){
 317 // Get the global z coordinate of the given T0 alignable volume
 318 //
 319   Double_t *tr;
 320   TGeoPNEntry *pne = gGeoManager->GetAlignableEntry(symname);
 321   if (!pne) return 0;
 322
 323
 324   TGeoPhysicalNode *pnode = pne->GetPhysicalNode();
 325   if(pnode){
 326           TGeoHMatrix* hm = pnode->GetMatrix();
 327            tr = hm->GetTranslation();
 328   }else{
 329           const char* path = pne->GetTitle();
 330           if(!gGeoManager->cd(path)){
 331                   AliErrorClass(Form("Volume path %s not valid!",path));
 332                   return 0;
 333           }
 334          tr = gGeoManager->GetCurrentMatrix()->GetTranslation();
 335   }
 336   return tr[2];
 337
 338 }
 339 //________________________________________________________________________________
 340
 341 Double_t AliT0Parameters::GetZPositionShift(const char* symname)
 342 {
 343 // Get the global z coordinate of the given T0 alignable volume
 344 //
 345   Double_t *tr = AliGeomManager::GetMatrix(symname)->GetTranslation();
 346
 347   TGeoHMatrix origmat;
 348   AliGeomManager::GetOrigGlobalMatrix(symname,origmat);
 349   Double_t *otr = origmat.GetTranslation();
 350
 351   return (tr[2]-otr[2]);
 352 }
 353