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