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