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   fNumberOfTRMs = 2;
 153   Int_t trm=0; Int_t tdc=0; Int_t chain=0; Int_t channel=0;
 154   for (Int_t ik=0; ik<105; ik++)
 155         {
 156          AliT0LookUpKey * lookkey= new AliT0LookUpKey();
 157          AliT0LookUpValue * lookvalue= new AliT0LookUpValue();
 158
 159
 160           lookvalue->SetTRM(trm);
 161           lookvalue->SetTDC(tdc);
 162           lookvalue->SetChain(chain);
 163           lookvalue->SetChannel(channel);
 164           lookkey->SetKey(ik);
 165           if (channel<6) channel +=2;
 166           else {channel = 0; tdc++;}
 167            if(ik==57) { tdc=0; channel=0; trm=1;}
 168            //           fLookUp.Add((TObject*)lookvalue,(TObject*)lookkey);
 169          fgLookUp->GetMapLookup()->Add((TObject*)lookvalue,(TObject*)lookkey);
 170        }
 171
 172   fIsInit=kTRUE;
 173 }
 174 //__________________________________________________________________
 175
 176 Float_t
 177 AliT0Parameters::GetTimeDelayDA(Int_t ipmt)
 178 {
 179   // return time delay for LED channel
 180   //
 181   if (!fCalibentry) {
 182     fTimeDelayDA = 500;
 183     return  fTimeDelayDA;
 184   }
 185   return fgCalibData ->GetTimeDelayDA(ipmt);
 186 }
 187 //__________________________________________________________________
 188 Float_t
 189 AliT0Parameters::GetTimeDelayCFD(Int_t ipmt)
 190 {
 191   // return time delay for CFD channel
 192    //
 193   if (!fCalibentry)
 194     {
 195       fTimeDelayCFD = 1000+ipmt*100;
 196       return fTimeDelayCFD;
 197     }
 198
 199   return fgCalibData->GetTimeDelayCFD(ipmt);
 200 }
 201
 202 //__________________________________________________________________
 203 Int_t
 204 AliT0Parameters::GetMeanT0()
 205 {
 206   // return mean of T0 distrubution with vertex=0
 207    //
 208   if (!fCalibentry)
 209     {
 210       return fMeanT0;
 211     }
 212
 213   return fgCalibData->GetMeanT0();
 214 }
 215 //__________________________________________________________________
 216
 217 TGraph *AliT0Parameters::GetAmpLEDRec(Int_t ipmt) const
 218 {
 219    if (!fSlewCorr) {
 220      AliError("No slewing correction is available!");
 221      return  (TGraph*)fAmpLEDRec.At(ipmt);
 222   }
 223   return fgSlewCorr -> GetAmpLEDRec(ipmt) ;
 224 }
 225
 226 //__________________________________________________________________
 227
 228 TGraph *AliT0Parameters::GetWalk(Int_t ipmt) const
 229 {
 230   if (!fSlewCorr) {
 231     AliError("No walk correction is available!");
 232     return  (TGraph*)fWalk.At(ipmt);
 233   }
 234   return fgSlewCorr -> GetWalk(ipmt) ;
 235 }
 236
 237 //__________________________________________________________________
 238
 239 Float_t AliT0Parameters::GetWalkVal(Int_t ipmt, Float_t mv) const
 240 {
 241   if (!fSlewCorr) {
 242     return ((TGraph*)fWalk.At(ipmt))->Eval(mv);
 243   }
 244   return fgSlewCorr -> GetWalkVal(ipmt, mv) ;
 245 }
 246
 247
 248 //__________________________________________________________________
 249 void
 250 AliT0Parameters::SetPMTeff(Int_t ipmt)
 251 {
 252   Float_t lambda[50];
 253   Float_t eff[50 ] = {0,        0,       0.23619,  0.202909, 0.177913,
 254                     0.175667, 0.17856, 0.190769, 0.206667, 0.230286,
 255                     0.252276, 0.256267,0.26,     0.27125,  0.281818,
 256                     0.288118, 0.294057,0.296222, 0.301622, 0.290421,
 257                     0.276615, 0.2666,  0.248,    0.23619,  0.227814,
 258                     0.219818, 0.206667,0.194087, 0.184681, 0.167917,
 259                     0.154367, 0.1364,  0.109412, 0.0834615,0.0725283,
 260                     0.0642963,0.05861, 0.0465,   0.0413333,0.032069,
 261                     0.0252203,0.02066, 0.016262, 0.012,    0.00590476,
 262                     0.003875, 0.00190, 0,        0,        0          } ;
 263   for (Int_t i=0; i<50; i++) lambda[i]=200+10*i;
 264
 265   TGraph* gr = new TGraph(50,lambda,eff);
 266   fPMTeff.AddAtAndExpand(gr,ipmt);
 267 }
 268 //________________________________________________________________
 269
 270 Int_t
 271 AliT0Parameters::GetChannel(Int_t trm,  Int_t tdc, Int_t chain, Int_t channel)
 272 {
 273
 274   if (fgLookUp) {
 275     AliT0LookUpValue key(trm,tdc,chain,channel);
 276       AliT0LookUpKey *val = (AliT0LookUpKey*) fgLookUp->GetMapLookup()->GetValue((TObject*)&key);
 277       // AliT0LookUpKey *val = (AliT0LookUpKey*) fLookUp.GetValue((TObject*)&key);
 278     if (val )
 279       return val->GetKey();
 280     else {
 281       AliWarning(Form("No such address (%d %d %d %d)!",trm,tdc,chain,channel));
 282       return -1;
 283     }
 284   }
 285   else {
 286     AliError("No look up table has been loader!");
 287     return -1;
 288   }
 289
 290 }
 291 //__________________________________________________________________
 292 TMap *AliT0Parameters::GetMapLookup()
 293 {
 294   if (!fgLookUp){
 295     cout<<" No look up table in OCDB";
 296     return 0;
 297   }
 298   return   fgLookUp->GetMapLookup();
 299 }
 300 //__________________________________________________________________
 301
 302 Int_t
 303 AliT0Parameters::GetNumberOfTRMs()
 304 {
 305   // return number of trms
 306   //
 307   if (!fgLookUp) {
 308     //  fNumberOfTRMs = 2;
 309     return  fNumberOfTRMs;
 310   }
 311   return  fgLookUp ->GetNumberOfTRMs();
 312 }
 313 /*
 314 //________________________________________________________________________________
 315 Double_t AliT0Parameters::GetZPosition(const char* symname){
 316 // Get the global z coordinate of the given T0 alignable volume
 317 //
 318   Double_t *tr = AliGeomManager::GetMatrix(symname)->GetTranslation();
 319
 320   return tr[2];
 321 }
 322 */
 323 //________________________________________________________________________________
 324 Double_t AliT0Parameters::GetZPosition(const char* symname){
 325 // Get the global z coordinate of the given T0 alignable volume
 326 //
 327   Double_t *tr;
 328
 329   cout<<symname<<endl;
 330   TGeoPNEntry *pne = gGeoManager->GetAlignableEntry(symname);
 331   if (!pne) return 0;
 332
 333
 334   TGeoPhysicalNode *pnode = pne->GetPhysicalNode();
 335   if(pnode){
 336           TGeoHMatrix* hm = pnode->GetMatrix();
 337            tr = hm->GetTranslation();
 338   }else{
 339           const char* path = pne->GetTitle();
 340           if(!gGeoManager->cd(path)){
 341                   AliErrorClass(Form("Volume path %s not valid!",path));
 342                   return 0;
 343           }
 344          tr = gGeoManager->GetCurrentMatrix()->GetTranslation();
 345   }
 346   return tr[2];
 347
 348 }
 349 //________________________________________________________________________________
 350
 351 Double_t AliT0Parameters::GetZPositionShift(const char* symname)
 352 {
 353 // Get the global z coordinate of the given T0 alignable volume
 354 //
 355   Double_t *tr = AliGeomManager::GetMatrix(symname)->GetTranslation();
 356
 357   TGeoHMatrix origmat;
 358   AliGeomManager::GetOrigGlobalMatrix(symname,origmat);
 359   Double_t *otr = origmat.GetTranslation();
 360
 361   return (tr[2]-otr[2]);
 362 }
 363