VZERO/AliVZEROTriggerMask.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 // Class : AliVZEROTriggerMask
  19 //
  20 // Fill up the trigger mask word.
  21 //
  22
  23 #include <Riostream.h>
  24 #include <TGeoManager.h>
  25 #include <TGeoMatrix.h>
  26 #include <TGeoPhysicalNode.h>
  27 #include <TF1.h>
  28 #include <TMath.h>
  29
  30 #include <AliGeomManager.h>
  31 #include "AliLog.h"
  32 #include "AliVZEROTriggerMask.h"
  33 #include "AliVZEROConst.h"
  34 #include "AliVZEROCalibData.h"
  35 #include "AliESDVZERO.h"
  36 #include "AliVZEROReconstructor.h"
  37
  38 //______________________________________________________________________
  39 ClassImp(AliVZEROTriggerMask)
  40
  41 //______________________________________________________________________
  42
  43 AliVZEROTriggerMask::AliVZEROTriggerMask()
  44   :TObject(),
  45    fAdcThresHold(0.0),
  46    fTimeWindowBBALow(-9.5),
  47    fTimeWindowBBAUp(22.5),
  48    fTimeWindowBGALow(-2.5),
  49    fTimeWindowBGAUp(5.0),
  50    fTimeWindowFakeALow(-17.5),
  51    fTimeWindowFakeAUp(-9.5),
  52    fTimeWindowBBCLow(-2.5),
  53    fTimeWindowBBCUp(22.5),
  54    fTimeWindowBGCLow(-2.5),
  55    fTimeWindowBGCUp(2.5),
  56    fTimeWindowFakeCLow(-22.5),
  57    fTimeWindowFakeCUp(-8.5),
  58    fV0ADist(0),
  59    fV0CDist(0)
  60 {
  61   // Default constructor
  62   //
  63   Float_t zV0A = TMath::Abs(GetZPosition("VZERO/V0A"));
  64   Float_t zV0C = TMath::Abs(GetZPosition("VZERO/V0C"));
  65
  66   // distance in time units from nominal vertex to V0
  67   fV0ADist = zV0A/TMath::Ccgs()*1e9;
  68   fV0CDist = zV0C/TMath::Ccgs()*1e9;
  69 }
  70
  71 //________________________________________________________________________________
  72 Double_t AliVZEROTriggerMask::GetZPosition(const char* symname){
  73 // Get the global z coordinate of the given V0 alignable volume
  74 //
  75   Double_t *tr;
  76   TGeoPNEntry *pne = gGeoManager->GetAlignableEntry(symname);
  77   if (!pne) {
  78     AliFatalClass(Form("TGeoPNEntry with symbolic name %s does not exist!",symname));
  79     return 0;
  80   }
  81
  82   TGeoPhysicalNode *pnode = pne->GetPhysicalNode();
  83   if(pnode){
  84           TGeoHMatrix* hm = pnode->GetMatrix();
  85            tr = hm->GetTranslation();
  86   }else{
  87           const char* path = pne->GetTitle();
  88           if(!gGeoManager->cd(path)){
  89                   AliFatalClass(Form("Volume path %s not valid!",path));
  90                   return 0;
  91           }
  92          tr = gGeoManager->GetCurrentMatrix()->GetTranslation();
  93   }
  94   return tr[2];
  95
  96 }
  97
  98 //________________________________________________________________________________
  99
 100
 101 void AliVZEROTriggerMask::FillMasks(AliESDVZERO *esdV0,
 102                                     AliVZEROCalibData *cal,
 103                                     TF1 *slewing)
 104 {
 105   // Fill up the trigger mask word
 106   // using the TDC data (already corrected for
 107   // slewing and misalignment between channels)
 108
 109   esdV0->SetBit(AliESDVZERO::kTriggerBitsFilled,kTRUE);
 110   esdV0->SetBit(AliESDVZERO::kDecisionFilled,kTRUE);
 111
 112   UInt_t aBBtriggerV0A = 0; // bit mask for Beam-Beam trigger in V0A
 113   UInt_t aBGtriggerV0A = 0; // bit mask for Beam-Gas trigger in V0A
 114   UInt_t aBBtriggerV0C = 0; // bit mask for Beam-Beam trigger in V0C
 115   UInt_t aBGtriggerV0C = 0; // bit mask for Beam-Gas trigger in V0C
 116
 117   const Float_t p1 = 2.50; // photostatistics term in the time resolution
 118   const Float_t p2 = 3.00; // slewing related term in the time resolution
 119
 120   // loop over vzero channels
 121   Float_t timeAW = 0,timeCW = 0;
 122   Float_t weightA = 0,weightC = 0;
 123   Int_t ntimeA = 0, ntimeC = 0;
 124   for (Int_t i = 0; i < 64; ++i) {
 125     Float_t adc = esdV0->GetAdc(i);
 126     if (adc > fAdcThresHold) {
 127       Float_t tdc = esdV0->GetTime(i);
 128       if (tdc > (AliVZEROReconstructor::kInvalidTime + 1e-6)) {
 129         Float_t nphe = adc*kChargePerADC/(cal->GetGain(i)*TMath::Qe());
 130         Float_t timeErr = TMath::Sqrt(kIntTimeRes*kIntTimeRes+
 131                                       p1*p1/nphe+
 132                                       p2*p2*(slewing->GetParameter(0)*slewing->GetParameter(1))*(slewing->GetParameter(0)*slewing->GetParameter(1))*
 133                                       TMath::Power(adc/cal->GetDiscriThr(i),2.*(slewing->GetParameter(1)-1.))/
 134                                       (cal->GetDiscriThr(i)*cal->GetDiscriThr(i)));
 135
 136         if (i < 32) { // in V0C
 137           ntimeC++;
 138           timeCW += tdc/(timeErr*timeErr);
 139           weightC += 1.0/(timeErr*timeErr);
 140
 141           if (tdc > (fV0CDist + fTimeWindowBBCLow) &&
 142               tdc < (fV0CDist + fTimeWindowBBCUp))
 143             aBBtriggerV0C |= (1 << i);
 144           if (tdc > (-fV0CDist + fTimeWindowBGCLow) &&
 145               tdc < (-fV0CDist + fTimeWindowBGCUp))
 146             aBGtriggerV0C |= (1 << i);
 147         }
 148         else { // in V0A
 149           ntimeA++;
 150           timeAW += tdc/(timeErr*timeErr);
 151           weightA += 1.0/(timeErr*timeErr);
 152
 153           Int_t shift = i - 32;
 154           if (tdc > (fV0ADist + fTimeWindowBBALow) &&
 155               tdc < (fV0ADist + fTimeWindowBBAUp))
 156             aBBtriggerV0A |= (1 << shift);
 157           if (tdc > (-fV0ADist + fTimeWindowBGALow) &&
 158               tdc < (-fV0ADist + fTimeWindowBGAUp))
 159             aBGtriggerV0A |= (1 << shift);
 160         }
 161       }
 162     }
 163   } // end of loop over channels
 164
 165   esdV0->SetBBtriggerV0A(aBBtriggerV0A);
 166   esdV0->SetBGtriggerV0A(aBGtriggerV0A);
 167   esdV0->SetBBtriggerV0C(aBBtriggerV0C);
 168   esdV0->SetBGtriggerV0C(aBGtriggerV0C);
 169
 170   if (weightA > 0) timeAW = timeAW/weightA;
 171   else timeAW = AliVZEROReconstructor::kInvalidTime;
 172
 173   if (weightC > 0) timeCW = timeCW/weightC;
 174   else timeCW = AliVZEROReconstructor::kInvalidTime;
 175
 176   esdV0->SetV0ATime(timeAW);
 177   esdV0->SetV0CTime(timeCW);
 178   esdV0->SetV0ATimeError((weightA > 0) ? (1./TMath::Sqrt(weightA)) : 0);
 179   esdV0->SetV0CTimeError((weightC > 0) ? (1./TMath::Sqrt(weightC)) : 0);
 180
 181   esdV0->SetV0ADecision(AliESDVZERO::kV0Empty);
 182   esdV0->SetV0CDecision(AliESDVZERO::kV0Empty);
 183
 184   if (timeAW > (fV0ADist + fTimeWindowBBALow) &&
 185       timeAW < (fV0ADist + fTimeWindowBBAUp))
 186     esdV0->SetV0ADecision(AliESDVZERO::kV0BB);
 187   else if (timeAW > (-fV0ADist + fTimeWindowBGALow) &&
 188            timeAW < (-fV0ADist + fTimeWindowBGAUp))
 189     esdV0->SetV0ADecision(AliESDVZERO::kV0BG);
 190   else if (timeAW > (fV0ADist + fTimeWindowFakeALow) &&
 191            timeAW < (fV0ADist + fTimeWindowFakeAUp))
 192     esdV0->SetV0ADecision(AliESDVZERO::kV0Fake);
 193
 194   if (timeCW > (fV0CDist + fTimeWindowBBCLow) &&
 195       timeCW < (fV0CDist + fTimeWindowBBCUp))
 196     esdV0->SetV0CDecision(AliESDVZERO::kV0BB);
 197   else if (timeCW > (-fV0CDist + fTimeWindowBGCLow) &&
 198            timeCW < (-fV0CDist + fTimeWindowBGCUp))
 199     esdV0->SetV0CDecision(AliESDVZERO::kV0BG);
 200   else if (timeCW > (fV0CDist + fTimeWindowFakeCLow) &&
 201            timeCW < (fV0CDist + fTimeWindowFakeCUp))
 202     esdV0->SetV0CDecision(AliESDVZERO::kV0Fake);
 203
 204 }