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
  40 AliT0CalibData* AliT0Parameters::fgCalibData = 0;
  41 AliT0CalibData* AliT0Parameters::fgLookUp = 0;
  42 AliT0CalibData* AliT0Parameters::fgSlewCorr =0;
  43 //====================================================================
  44 ClassImp(AliT0Parameters)
  45 #if 0
  46   ; // This is here to keep Emacs for indenting the next line
  47 #endif
  48
  49 //____________________________________________________________________
  50 AliT0Parameters* AliT0Parameters::fgInstance = 0;
  51 //____________________________________________________________________
  52 AliT0Parameters* AliT0Parameters::Instance()
  53 {
  54   // Get static instance
  55   if (!fgInstance) {
  56     fgInstance = new AliT0Parameters;
  57     //   fgInstance->Init();
  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    fPMTeff(),
  69    fCalibentry(), fLookUpentry(),fSlewCorr(),
  70    fLookUp(0), fNumberOfTRMs(2)
  71
  72 {
  73   // Default constructor
  74   for (Int_t ipmt=0; ipmt<24; ipmt++)
  75     {
  76       SetPh2Mip();
  77       SetmV2Mip();
  78       SetChannelWidth();
  79       SetmV2channel();
  80       SetQTmin();
  81       SetQTmax();
  82       SetPMTeff(ipmt);
  83     }
  84   SetTimeDelayTVD();
  85   SetZposition();
  86
  87 }
  88
  89 //__________________________________________________________________
  90 void
  91 AliT0Parameters::Init()
  92 {
  93   // Initialize the parameters manager.  We need to get stuff from the
  94   // CDB here.
  95    if (fIsInit) return;
  96
  97    AliCDBManager *stor =AliCDBManager::Instance();
  98
  99    //time equalizing
 100   fCalibentry  = stor->Get("T0/Calib/TimeDelay");
 101   if (fCalibentry)
 102    fgCalibData  = (AliT0CalibData*)fCalibentry->GetObject();
 103   else {
 104     AliFatal(" ALARM !!!! No time delays in CDB ");
 105     fIsInit = kFALSE;
 106     return;
 107   }
 108  //slewing correction
 109   fSlewCorr  = stor->Get("T0/Calib/Slewing_Walk");
 110   if (fSlewCorr){
 111     fgSlewCorr  = (AliT0CalibData*)fSlewCorr->GetObject();
 112   }
 113   else {
 114     AliFatal(" ALARM !!!! No slewing correction in CDB ");
 115     fIsInit = kFALSE;
 116     return;
 117   }
 118   //lookup table
 119   fLookUpentry  = stor->Get("T0/Calib/LookUp_Table");
 120   if (fLookUpentry){
 121     fgLookUp  = (AliT0CalibData*)fLookUpentry->GetObject();
 122   }
 123   else {
 124     AliFatal(" ALARM !!!! No Lookup table  in CDB ");
 125     fIsInit = kFALSE;
 126     return;
 127   }
 128   fIsInit = kTRUE;
 129 }
 130
 131
 132 //__________________________________________________________________
 133
 134 void AliT0Parameters::InitIfOnline()
 135 {
 136 // should be used in online
 137 // for switching to this one should write
 138   // AliT0RawReader myrawreader(rawReader);
 139 //      myrawreader.SetOnlineMode(kTRUE);
 140
 141
 142   if (fIsInit) return;
 143
 144   Int_t trm=0; Int_t tdc=0; Int_t chain=0; Int_t channel=0;
 145   for (Int_t ik=0; ik<110; ik++)
 146         {
 147          AliT0LookUpKey * lookkey= new AliT0LookUpKey();
 148          AliT0LookUpValue * lookvalue= new AliT0LookUpValue();
 149
 150
 151           lookvalue->SetTRM(trm);
 152           lookvalue->SetTDC(tdc);
 153           lookvalue->SetChain(chain);
 154           lookvalue->SetChannel(channel);
 155           lookkey->SetKey(ik);
 156           if(ik==55) { trm=1; tdc=0; channel=0;}
 157           if (channel<6) channel +=2;
 158           else {channel = 0; tdc++;}
 159           fLookUp.Add((TObject*)lookvalue,(TObject*)lookkey);
 160        }
 161
 162   fIsInit=kTRUE;
 163 }
 164 //__________________________________________________________________
 165
 166 Float_t
 167 AliT0Parameters::GetTimeDelayDA(Int_t ipmt)
 168 {
 169   // return time delay for LED channel
 170   //
 171   if (!fCalibentry) {
 172     fTimeDelayDA = 500;
 173     return  fTimeDelayDA;
 174   }
 175   return fgCalibData ->GetTimeDelayDA(ipmt);
 176 }
 177 //__________________________________________________________________
 178 Float_t
 179 AliT0Parameters::GetTimeDelayCFD(Int_t ipmt)
 180 {
 181   // return time delay for CFD channel
 182    //
 183   if (!fCalibentry)
 184     {
 185       fTimeDelayCFD = 1000+ipmt*100;
 186       return fTimeDelayCFD;
 187     }
 188
 189   return fgCalibData->GetTimeDelayCFD(ipmt);
 190 }
 191
 192 //__________________________________________________________________
 193 Int_t
 194 AliT0Parameters::GetMeanT0()
 195 {
 196   // return mean of T0 distrubution with vertex=0
 197    //
 198   if (!fCalibentry)
 199     {
 200       return fMeanT0;
 201     }
 202
 203   return fgCalibData->GetMeanT0();
 204 }
 205 //__________________________________________________________________
 206
 207 TGraph *AliT0Parameters::GetAmpLED(Int_t ipmt) const
 208 {
 209   if (!fSlewCorr) {
 210     return  (TGraph*)fAmpLED.At(ipmt);
 211   }
 212   return fgSlewCorr -> GetAmpLED(ipmt) ;
 213 }
 214
 215 //__________________________________________________________________
 216
 217 TGraph *AliT0Parameters::GetAmpLEDRec(Int_t ipmt) const
 218 {
 219    if (!fSlewCorr) {
 220      cout<<"AliT0Parameters::GetSlewingRec !fSlewCorr"<<endl;
 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     cout<<" AliT0Parameters::GetWalk "<<fSlewCorr<<endl;
 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
 275   AliT0LookUpKey * lookkey;  //= new AliT0LookUpKey();
 276   AliT0LookUpValue * lookvalue= new AliT0LookUpValue(trm,tdc,chain,channel);
 277   if (fgLookUp)
 278        lookkey = (AliT0LookUpKey*) fgLookUp->GetMapLookup()->GetValue((TObject*)lookvalue);
 279    else
 280    lookkey = (AliT0LookUpKey*) fLookUp.GetValue((TObject*)lookvalue);
 281
 282   if (!lookkey ) {
 283     cout<<" no such address "<<endl; return -1;
 284   }
 285
 286
 287   //cout<<"AliT0Parameters:: key "<<lookkey->GetKey()<<endl;
 288   return lookkey->GetKey();
 289
 290
 291 }
 292 //__________________________________________________________________
 293 Int_t
 294 AliT0Parameters::GetNumberOfTRMs()
 295 {
 296   // return number of trms
 297   //
 298   if (!fgLookUp) {
 299     fNumberOfTRMs = 2;
 300     return  fNumberOfTRMs;
 301   }
 302   return  fgLookUp ->GetNumberOfTRMs();
 303 }
 304 //________________________________________________________________________________
 305 Double_t AliT0Parameters::GetZPosition(const char* symname){
 306 // Get the global z coordinate of the given T0 alignable volume
 307 //
 308   Double_t *tr;
 309
 310   cout<<symname<<endl;
 311   TGeoPNEntry *pne = gGeoManager->GetAlignableEntry(symname);
 312   if (!pne) return 0;
 313
 314
 315   TGeoPhysicalNode *pnode = pne->GetPhysicalNode();
 316   if(pnode){
 317           TGeoHMatrix* hm = pnode->GetMatrix();
 318            tr = hm->GetTranslation();
 319   }else{
 320           const char* path = pne->GetTitle();
 321           if(!gGeoManager->cd(path)){
 322                   AliErrorClass(Form("Volume path %s not valid!",path));
 323                   return 0;
 324           }
 325          tr = gGeoManager->GetCurrentMatrix()->GetTranslation();
 326   }
 327   return tr[2];
 328
 329 }
 330