1 /**************************************************************************
2 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
4 * Author: The ALICE Off-line Project. *
5 * Contributors are mentioned in the code where appropriate. *
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 **************************************************************************/
18 ///////////////////////////////////////////////////////////////////////////////
20 /// class for VZERO reconstruction //
22 ///////////////////////////////////////////////////////////////////////////////
27 #include "AliRunLoader.h"
28 #include "AliRawReader.h"
29 #include "AliGRPObject.h"
30 #include "AliCDBManager.h"
31 #include "AliCDBStorage.h"
32 #include "AliCDBEntry.h"
33 #include "AliVZEROReconstructor.h"
34 #include "AliVZERORawStream.h"
35 #include "AliVZEROConst.h"
36 #include "AliESDEvent.h"
37 #include "AliVZEROTriggerMask.h"
38 #include "AliESDfriend.h"
39 #include "AliESDVZEROfriend.h"
40 #include "AliVZEROdigit.h"
41 #include "AliVZEROCalibData.h"
42 #include "AliRunInfo.h"
43 #include "AliCTPTimeParams.h"
45 ClassImp(AliVZEROReconstructor)
47 //_____________________________________________________________________________
48 AliVZEROReconstructor:: AliVZEROReconstructor(): AliReconstructor(),
58 // Default constructor
59 // Get calibration data
61 fCalibData = GetCalibData();
63 AliCDBEntry *entry = AliCDBManager::Instance()->Get("GRP/CTP/CTPtiming");
64 if (!entry) AliFatal("CTP timing parameters are not found in OCDB !");
65 AliCTPTimeParams *ctpParams = (AliCTPTimeParams*)entry->GetObject();
66 Float_t l1Delay = (Float_t)ctpParams->GetDelayL1L0()*25.0;
68 AliCDBEntry *entry2 = AliCDBManager::Instance()->Get("VZERO/Calib/TimeDelays");
69 if (!entry2) AliFatal("VZERO time delays are not found in OCDB !");
70 TH1F *delays = (TH1F*)entry2->GetObject();
72 AliCDBEntry *entry3 = AliCDBManager::Instance()->Get("VZERO/Calib/TimeSlewing");
73 if (!entry3) AliFatal("VZERO time slewing function is not found in OCDB !");
74 fTimeSlewing = (TF1*)entry3->GetObject();
76 for(Int_t i = 0 ; i < 64; ++i) {
77 Int_t board = AliVZEROCalibData::GetBoardNumber(i);
78 fTimeOffset[i] = (((Float_t)fCalibData->GetTriggerCountOffset(board)-
79 (Float_t)fCalibData->GetRollOver(board))*25.0+
80 fCalibData->GetTimeOffset(i)+
82 delays->GetBinContent(i+1)+
88 //_____________________________________________________________________________
89 AliVZEROReconstructor& AliVZEROReconstructor::operator =
90 (const AliVZEROReconstructor& /*reconstructor*/)
92 // assignment operator
94 Fatal("operator =", "assignment operator not implemented");
98 //_____________________________________________________________________________
99 AliVZEROReconstructor::~AliVZEROReconstructor()
104 delete fESDVZEROfriend;
108 //_____________________________________________________________________________
109 void AliVZEROReconstructor::Init()
113 fESDVZERO = new AliESDVZERO;
114 fESDVZEROfriend = new AliESDVZEROfriend;
116 GetCollisionMode(); // fCollisionMode =1 for Pb-Pb simulated data
119 //______________________________________________________________________
120 void AliVZEROReconstructor::ConvertDigits(AliRawReader* rawReader, TTree* digitsTree) const
122 // converts RAW to digits
125 AliError("No digits tree!");
130 fDigitsArray = new TClonesArray("AliVZEROdigit", 64);
131 digitsTree->Branch("VZERODigit", &fDigitsArray);
133 fESDVZEROfriend->Reset();
136 AliVZERORawStream rawStream(rawReader);
137 if (rawStream.Next()) {
139 Float_t time[64], width[64];
140 Bool_t BBFlag[64], BGFlag[64], integrator[64];
141 for(Int_t i=0; i<64; i++) {
142 Int_t j = rawStream.GetOfflineChannel(i);
148 integrator[j] = kFALSE;
149 // Search for the maximum charge in the train of 21 LHC clocks
150 // regardless of the integrator which has been operated:
153 Float_t adcPedSub[21];
154 for(Int_t iClock=0; iClock<21; iClock++){
155 Bool_t iIntegrator = rawStream.GetIntegratorFlag(i,iClock);
156 Int_t k = j+64*iIntegrator;
157 adcPedSub[iClock] = rawStream.GetPedestal(i,iClock) - fCalibData->GetPedestal(k);
158 if(adcPedSub[iClock] <= GetRecoParam()->GetNSigmaPed()*fCalibData->GetSigma(k)) {
159 adcPedSub[iClock] = 0;
162 if(iClock < GetRecoParam()->GetStartClock() || iClock > GetRecoParam()->GetEndClock()) continue;
163 if(adcPedSub[iClock] > maxadc) {
164 maxadc = adcPedSub[iClock];
169 AliDebug(2,Form("Channel %d (online), %d (offline)",i,j));
171 Int_t start = imax - GetRecoParam()->GetNPreClocks();
172 if (start < 0) start = 0;
173 Int_t end = imax + GetRecoParam()->GetNPostClocks();
174 if (end > 20) end = 20;
175 for(Int_t iClock = start; iClock <= end; iClock++) {
176 if (iClock >= imax) {
177 BBFlag[j] |= rawStream.GetBBFlag(i,iClock);
178 BGFlag[j] |= rawStream.GetBGFlag(i,iClock);
181 adc[j] += rawStream.GetPedestal(i,iClock);
183 adc[j] += adcPedSub[iClock];
185 AliDebug(2,Form("clock = %d adc = %f",iClock,rawStream.GetPedestal(i,iClock)));
187 // Convert i (FEE channel numbering) to j (aliroot channel numbering)
189 integrator[j] = rawStream.GetIntegratorFlag(i,imax);
193 time[j] = rawStream.GetTime(i)/ (25./256.) * fCalibData->GetTimeResolution(board);
194 width[j] = rawStream.GetWidth(i) / 0.4 * fCalibData->GetWidthResolution(board);
196 // Filling the esd friend object
197 fESDVZEROfriend->SetBBScalers(j,rawStream.GetBBScalers(i));
198 fESDVZEROfriend->SetBGScalers(j,rawStream.GetBGScalers(i));
199 for (Int_t iBunch = 0; iBunch < AliESDVZEROfriend::kNBunches; iBunch++) {
200 fESDVZEROfriend->SetChargeMB(j,iBunch,rawStream.GetChargeMB(i,iBunch));
201 fESDVZEROfriend->SetIntMBFlag(j,iBunch,rawStream.GetIntMBFlag(i,iBunch));
202 fESDVZEROfriend->SetBBMBFlag(j,iBunch,rawStream.GetBBMBFlag(i,iBunch));
203 fESDVZEROfriend->SetBGMBFlag(j,iBunch,rawStream.GetBGMBFlag(i,iBunch));
205 for (Int_t iEv = 0; iEv < AliESDVZEROfriend::kNEvOfInt; iEv++) {
206 fESDVZEROfriend->SetPedestal(j,iEv,rawStream.GetPedestal(i,iEv));
207 fESDVZEROfriend->SetIntegratorFlag(j,iEv,rawStream.GetIntegratorFlag(i,iEv));
208 fESDVZEROfriend->SetBBFlag(j,iEv,rawStream.GetBBFlag(i,iEv));
209 fESDVZEROfriend->SetBGFlag(j,iEv,rawStream.GetBGFlag(i,iEv));
211 fESDVZEROfriend->SetTime(j,time[j]);
212 fESDVZEROfriend->SetWidth(j,width[j]);
215 // Filling the esd friend object
216 fESDVZEROfriend->SetTriggerInputs(rawStream.GetTriggerInputs());
217 fESDVZEROfriend->SetTriggerInputsMask(rawStream.GetTriggerInputsMask());
219 for(Int_t iScaler = 0; iScaler < AliESDVZEROfriend::kNScalers; iScaler++)
220 fESDVZEROfriend->SetTriggerScalers(iScaler,rawStream.GetTriggerScalers(iScaler));
222 for(Int_t iBunch = 0; iBunch < AliESDVZEROfriend::kNBunches; iBunch++)
223 fESDVZEROfriend->SetBunchNumbersMB(iBunch,rawStream.GetBunchNumbersMB(iBunch));
226 // Channels(aliroot numbering) will be ordered in the tree
227 for(Int_t iChannel = 0; iChannel < 64; iChannel++) {
228 if(fCalibData->IsChannelDead(iChannel)){
229 adc[iChannel] = (Float_t) kInvalidADC;
230 time[iChannel] = (Float_t) kInvalidTime;
232 if (adc[iChannel] > 0)
233 new ((*fDigitsArray)[fDigitsArray->GetEntriesFast()])
234 AliVZEROdigit(iChannel, adc[iChannel], time[iChannel],
235 width[iChannel], BBFlag[iChannel], BGFlag[iChannel],integrator[iChannel]);
241 fDigitsArray->Clear();
244 //______________________________________________________________________
245 void AliVZEROReconstructor::FillESD(TTree* digitsTree, TTree* /*clustersTree*/,
246 AliESDEvent* esd) const
248 // fills multiplicities to the ESD - pedestal is now subtracted
251 AliError("No digits tree!");
255 TBranch* digitBranch = digitsTree->GetBranch("VZERODigit");
256 digitBranch->SetAddress(&fDigitsArray);
265 for (Int_t i=0; i<64; i++){
268 time[i] = kInvalidTime;
274 // loop over VZERO entries to get multiplicity
275 Int_t nEntries = (Int_t)digitsTree->GetEntries();
276 for (Int_t e=0; e<nEntries; e++) {
277 digitsTree->GetEvent(e);
279 Int_t nDigits = fDigitsArray->GetEntriesFast();
281 for (Int_t d=0; d<nDigits; d++) {
282 AliVZEROdigit* digit = (AliVZEROdigit*) fDigitsArray->At(d);
283 Int_t pmNumber = digit->PMNumber();
284 // Pedestal retrieval and suppression:
285 Bool_t integrator = digit->Integrator();
286 Int_t k = pmNumber+64*integrator;
287 Float_t pedestal = fCalibData->GetPedestal(k);
288 adc[pmNumber] = digit->ADC() - pedestal;
289 time[pmNumber] = CorrectLeadingTime(pmNumber,digit->Time(),adc[pmNumber]);
290 width[pmNumber] = digit->Width();
291 BBFlag[pmNumber]= digit->BBFlag();
292 BGFlag[pmNumber]= digit->BGFlag();
294 AliDebug(2,Form("PM = %d ADC = %f TDC %f",pmNumber, digit->ADC(),digit->Time()));
296 if(adc[pmNumber] > (fCalibData->GetPedestal(k) + GetRecoParam()->GetNSigmaPed()*fCalibData->GetSigma(k))) {
297 mult[pmNumber] += adc[pmNumber]*fCalibData->GetMIPperADC(pmNumber);
299 } // end of loop over digits
300 } // end of loop over events in digits tree
302 fESDVZERO->SetBit(AliESDVZERO::kCorrectedLeadingTime,kTRUE);
303 fESDVZERO->SetMultiplicity(mult);
304 fESDVZERO->SetADC(adc);
305 fESDVZERO->SetTime(time);
306 fESDVZERO->SetWidth(width);
307 fESDVZERO->SetBBFlag(BBFlag);
308 fESDVZERO->SetBGFlag(BGFlag);
310 // now fill the V0 decision and channel flags
312 AliVZEROTriggerMask triggerMask;
313 triggerMask.FillMasks(fESDVZERO, fCalibData, fTimeSlewing);
317 AliDebug(1, Form("Writing VZERO data to ESD tree"));
318 esd->SetVZEROData(fESDVZERO);
322 AliESDfriend *fr = (AliESDfriend*)esd->FindListObject("AliESDfriend");
324 AliDebug(1, Form("Writing VZERO friend data to ESD tree"));
325 fr->SetVZEROfriend(fESDVZEROfriend);
329 fDigitsArray->Clear();
332 //_____________________________________________________________________________
333 AliCDBStorage* AliVZEROReconstructor::SetStorage(const char *uri)
337 Bool_t deleteManager = kFALSE;
339 AliCDBManager *manager = AliCDBManager::Instance();
340 AliCDBStorage *defstorage = manager->GetDefaultStorage();
342 if(!defstorage || !(defstorage->Contains("VZERO"))){
343 AliWarning("No default storage set or default storage doesn't contain VZERO!");
344 manager->SetDefaultStorage(uri);
345 deleteManager = kTRUE;
348 AliCDBStorage *storage = manager->GetDefaultStorage();
351 AliCDBManager::Instance()->UnsetDefaultStorage();
352 defstorage = 0; // the storage is killed by AliCDBManager::Instance()->Destroy()
358 //____________________________________________________________________________
359 void AliVZEROReconstructor::GetCollisionMode()
361 // Retrieval of collision mode
363 TString beamType = GetRunInfo()->GetBeamType();
364 if(beamType==AliGRPObject::GetInvalidString()){
365 AliError("VZERO cannot retrieve beam type");
369 if( (beamType.CompareTo("P-P") ==0) || (beamType.CompareTo("p-p") ==0) ){
372 else if( (beamType.CompareTo("Pb-Pb") ==0) || (beamType.CompareTo("A-A") ==0) ){
376 fBeamEnergy = GetRunInfo()->GetBeamEnergy();
377 if(fBeamEnergy==AliGRPObject::GetInvalidFloat()) {
378 AliError("Missing value for the beam energy ! Using 0");
382 AliDebug(1,Form("\n ++++++ Beam type and collision mode retrieved as %s %d @ %1.3f GeV ++++++\n\n",beamType.Data(), fCollisionMode, fBeamEnergy));
386 //_____________________________________________________________________________
387 AliVZEROCalibData* AliVZEROReconstructor::GetCalibData() const
389 // Gets calibration object for VZERO set
391 AliCDBManager *man = AliCDBManager::Instance();
393 AliCDBEntry *entry=0;
395 entry = man->Get("VZERO/Calib/Data");
397 AliVZEROCalibData *calibdata = 0;
399 if (entry) calibdata = (AliVZEROCalibData*) entry->GetObject();
400 if (!calibdata) AliFatal("No calibration data from calibration database !");
405 Float_t AliVZEROReconstructor::CorrectLeadingTime(Int_t i, Float_t time, Float_t adc) const
407 // Correct the leading time
408 // for slewing effect and
409 // misalignment of the channels
410 if (time < 1e-6) return kInvalidTime;
412 // Channel alignment and general offset subtraction
413 if (i < 32) time -= kV0CDelayCables;
414 time -= fTimeOffset[i];
416 // In case of pathological signals
417 if (adc < 1e-6) return time;
419 // Slewing correction
420 Float_t thr = fCalibData->GetDiscriThr(i);
421 time -= fTimeSlewing->Eval(adc/thr);