removed debug statement
[u/mrichter/AliRoot.git] / FMD / AliFMDReconstructor.cxx
CommitLineData
37c55dc0 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 **************************************************************************/
0d0e6995 15/* $Id$ */
c2fc1258 16/** @file AliFMDReconstructor.cxx
17 @author Christian Holm Christensen <cholm@nbi.dk>
18 @date Mon Mar 27 12:47:09 2006
19 @brief FMD reconstruction
20*/
4347b38f 21//____________________________________________________________________
42403906 22//
02a27b50 23// This is a class that constructs AliFMDRecPoint objects from of Digits
6169f936 24// This class reads either digits from a TClonesArray or raw data from
4347b38f 25// a DDL file (or similar), and stores the read ADC counts in an
6169f936 26// internal cache (fAdcs). The rec-points are made via the naiive
27// method.
4347b38f 28//
37c55dc0 29//-- Authors: Evgeny Karpechev(INR) and Alla Maevsksia
4347b38f 30// Latest changes by Christian Holm Christensen <cholm@nbi.dk>
31//
32//
33//____________________________________________________________________
37c55dc0 34
f95a63c4 35// #include <AliLog.h> // ALILOG_H
6169f936 36// #include <AliRun.h> // ALIRUN_H
f95a63c4 37#include "AliFMDDebug.h"
56b1929b 38#include <AliRunLoader.h> // ALIRUNLOADER_H
56b1929b 39#include <AliHeader.h> // ALIHEADER_H
56b1929b 40#include <AliGenEventHeader.h> // ALIGENEVENTHEADER_H
1a1fdef7 41#include "AliFMDGeometry.h" // ALIFMDGEOMETRY_H
42#include "AliFMDParameters.h" // ALIFMDPARAMETERS_H
56b1929b 43#include "AliFMDDigit.h" // ALIFMDDIGIT_H
44#include "AliFMDReconstructor.h" // ALIFMDRECONSTRUCTOR_H
56b1929b 45#include "AliFMDRawReader.h" // ALIFMDRAWREADER_H
bf000c32 46#include "AliFMDRecPoint.h" // ALIFMDMULTNAIIVE_H
af885e0f 47#include "AliESDEvent.h" // ALIESDEVENT_H
8f6ee336 48#include <AliESDFMD.h> // ALIESDFMD_H
9684be2f 49#include <TH1.h>
50#include <TH2.h>
51#include <TFile.h>
02a27b50 52class AliRawReader;
4347b38f 53
54//____________________________________________________________________
925e6570 55ClassImp(AliFMDReconstructor)
1a1fdef7 56#if 0
57 ; // This is here to keep Emacs for indenting the next line
58#endif
37c55dc0 59
4347b38f 60//____________________________________________________________________
61AliFMDReconstructor::AliFMDReconstructor()
62 : AliReconstructor(),
e9fd1e20 63 fMult(0x0),
64 fNMult(0),
65 fTreeR(0x0),
66 fCurrentVertex(0),
67 fESDObj(0x0),
9684be2f 68 fNoiseFactor(0),
69 fAngleCorrect(kTRUE),
70 fVertexType(kNoVertex),
71 fRunLoader(0x0),
72 fESD(0x0),
73 fDiagnostics(kFALSE),
74 fDiagStep1(0),
75 fDiagStep2(0),
76 fDiagStep3(0),
77 fDiagStep4(0),
78 fDiagAll(0)
4347b38f 79{
8f6ee336 80 // Make a new FMD reconstructor object - default CTOR.
a9579262 81 SetNoiseFactor();
82 SetAngleCorrect();
4347b38f 83}
84
42403906 85
86//____________________________________________________________________
87AliFMDReconstructor::AliFMDReconstructor(const AliFMDReconstructor& other)
8f6ee336 88 : AliReconstructor(),
89 fMult(other.fMult),
e9fd1e20 90 fNMult(other.fNMult),
91 fTreeR(other.fTreeR),
92 fCurrentVertex(other.fCurrentVertex),
93 fESDObj(other.fESDObj),
a9579262 94 fNoiseFactor(other.fNoiseFactor),
9684be2f 95 fAngleCorrect(other.fAngleCorrect),
96 fVertexType(other.fVertexType),
97 fRunLoader(other.fRunLoader),
98 fESD(other.fESD),
99 fDiagnostics(other.fDiagnostics),
100 fDiagStep1(other.fDiagStep1),
101 fDiagStep2(other.fDiagStep2),
102 fDiagStep3(other.fDiagStep3),
103 fDiagStep4(other.fDiagStep4),
104 fDiagAll(other.fDiagAll)
42403906 105{
56b1929b 106 // Copy constructor
42403906 107}
108
109
110//____________________________________________________________________
111AliFMDReconstructor&
112AliFMDReconstructor::operator=(const AliFMDReconstructor& other)
113{
56b1929b 114 // Assignment operator
a9579262 115 fMult = other.fMult;
116 fNMult = other.fNMult;
117 fTreeR = other.fTreeR;
e9fd1e20 118 fCurrentVertex = other.fCurrentVertex;
a9579262 119 fESDObj = other.fESDObj;
a9579262 120 fNoiseFactor = other.fNoiseFactor;
121 fAngleCorrect = other.fAngleCorrect;
9684be2f 122 fVertexType = other.fVertexType;
123 fRunLoader = other.fRunLoader;
124 fESD = other.fESD;
125 fDiagnostics = other.fDiagnostics;
126 fDiagStep1 = other.fDiagStep1;
127 fDiagStep2 = other.fDiagStep2;
128 fDiagStep3 = other.fDiagStep3;
129 fDiagStep4 = other.fDiagStep4;
130 fDiagAll = other.fDiagAll;
42403906 131 return *this;
132}
56b1929b 133
134//____________________________________________________________________
135AliFMDReconstructor::~AliFMDReconstructor()
136{
137 // Destructor
8f6ee336 138 if (fMult) fMult->Delete();
139 if (fMult) delete fMult;
140 if (fESDObj) delete fESDObj;
56b1929b 141}
4347b38f 142
143//____________________________________________________________________
144void
1a1fdef7 145AliFMDReconstructor::Init(AliRunLoader* runLoader)
146{
147 // Initialize the reconstructor
f95a63c4 148 AliFMDDebug(2, ("Init called with runloader 0x%x", runLoader));
bf000c32 149 // Initialize the geometry
9b48326f 150 AliFMDGeometry* geom = AliFMDGeometry::Instance();
151 geom->Init();
152 geom->InitTransformations();
153
154 // Initialize the parameters
155 AliFMDParameters* param = AliFMDParameters::Instance();
156 param->Init();
bf000c32 157
8f6ee336 158 // Current vertex position
1a1fdef7 159 fCurrentVertex = 0;
8f6ee336 160 // Create array of reconstructed strip multiplicities
bf000c32 161 fMult = new TClonesArray("AliFMDRecPoint", 51200);
8f6ee336 162 // Create ESD output object
163 fESDObj = new AliESDFMD;
164
165 // Check that we have a run loader
9684be2f 166 fRunLoader = runLoader;
8f6ee336 167
9684be2f 168 // Check if we need diagnostics histograms
169 if (!fDiagnostics) return;
170 fDiagStep1 = new TH2I("diagStep1", "Read ADC vs. Noise surpressed ADC",
171 1024, -.5, 1023.5, 1024, -.5, 1023.5);
172 fDiagStep1->SetDirectory(0);
173 fDiagStep1->GetXaxis()->SetTitle("ADC (read)");
174 fDiagStep1->GetYaxis()->SetTitle(Form("ADC (noise surpressed %4.f)",
175 fNoiseFactor));
176 fDiagStep2 = new TH2F("diagStep2", "ADC vs Edep deduced",
177 1024, -.5, 1023.5, 100, 0, 2);
178 fDiagStep2->SetDirectory(0);
179 fDiagStep2->GetXaxis()->SetTitle("ADC (noise surpressed)");
180 fDiagStep2->GetYaxis()->SetTitle("#Delta E [GeV]");
181 fDiagStep3 = new TH2F("diagStep3", "Edep vs Edep path corrected",
182 100, 0., 2., 100, 0., 2.);
183 fDiagStep3->SetDirectory(0);
184 fDiagStep3->GetXaxis()->SetTitle("#Delta E [GeV]");
185 fDiagStep3->GetYaxis()->SetTitle("#Delta E/#Delta x #times #delta x [GeV]");
186 fDiagStep4 = new TH2F("diagStep4", "Edep vs Multiplicity deduced",
187 100, 0., 2., 100, -.1, 19.9);
188 fDiagStep4->SetDirectory(0);
189 fDiagStep4->GetXaxis()->SetTitle("#Delta E/#Delta x #times #delta x [GeV]");
190 fDiagStep4->GetYaxis()->SetTitle("Multiplicity");
191 fDiagAll = new TH2F("diagAll", "Read ADC vs Multiplicity deduced",
192 1024, -.5, 1023.5, 100, -.1, 19.9);
193 fDiagAll->SetDirectory(0);
194 fDiagAll->GetXaxis()->SetTitle("ADC (read)");
195 fDiagAll->GetYaxis()->SetTitle("Multiplicity");
4347b38f 196}
dc8af42e 197
4347b38f 198//____________________________________________________________________
199void
1a1fdef7 200AliFMDReconstructor::ConvertDigits(AliRawReader* reader,
201 TTree* digitsTree) const
202{
203 // Convert Raw digits to AliFMDDigit's in a tree
f95a63c4 204 AliFMDDebug(2, ("Reading raw data into digits tree"));
1a1fdef7 205 AliFMDRawReader rawRead(reader, digitsTree);
206 // rawRead.SetSampleRate(fFMD->GetSampleRate());
207 rawRead.Exec();
4347b38f 208}
209
4347b38f 210//____________________________________________________________________
211void
9684be2f 212AliFMDReconstructor::GetVertex() const
4347b38f 213{
9684be2f 214 fVertexType = kNoVertex;
215 fCurrentVertex = 0;
a3537838 216 if (fESD) {
8f6ee336 217 const AliESDVertex* vertex = fESD->GetVertex();
218 if (vertex) {
f95a63c4 219 AliFMDDebug(2, ("Got vertex from ESD: %f", vertex->GetZv()));
8f6ee336 220 fCurrentVertex = vertex->GetZv();
9684be2f 221 fVertexType = kESDVertex;
222 return;
8f6ee336 223 }
a3537838 224 }
9684be2f 225 // Check if we can get the header tree
226 AliGenEventHeader* genHeader = ((!fRunLoader ||
227 !fRunLoader->GetHeader() ||
228 !fRunLoader->GetHeader()->GenEventHeader())
229 ? 0
230 : fRunLoader->GetHeader()->GenEventHeader());
231 if (genHeader) {
232 TArrayF vtx;
233 genHeader->PrimaryVertex(vtx);
234 fCurrentVertex = vtx[2];
235 fVertexType = kGenVertex;
f95a63c4 236 AliFMDDebug(2, ("Got vertex from generator: %f", fCurrentVertex));
9684be2f 237 AliWarning("Got vertex from generator event header");
238 return;
239 }
240 AliWarning("Didn't get any vertex from ESD or generator");
241}
242
243
244//____________________________________________________________________
245void
246AliFMDReconstructor::Reconstruct(TTree* digitsTree,
247 TTree* clusterTree) const
248{
249 // Reconstruct event from digits in tree
250 // Get the FMD branch holding the digits.
251 // FIXME: The vertex may not be known yet, so we may have to move
252 // some of this to FillESD.
f95a63c4 253 AliFMDDebug(2, ("Reconstructing from digits in a tree"));
9684be2f 254 GetVertex();
255
1a1fdef7 256 TBranch *digitBranch = digitsTree->GetBranch("FMD");
4347b38f 257 if (!digitBranch) {
1a1fdef7 258 Error("Exec", "No digit branch for the FMD found");
259 return;
4347b38f 260 }
0abe7182 261 TClonesArray* digits = new TClonesArray("AliFMDDigit");
1a1fdef7 262 digitBranch->SetAddress(&digits);
4347b38f 263
8f6ee336 264 if (fMult) fMult->Clear();
265 if (fESDObj) fESDObj->Clear();
266
267 fNMult = 0;
268 fTreeR = clusterTree;
269 fTreeR->Branch("FMD", &fMult);
270
f95a63c4 271 AliFMDDebug(5, ("Getting entry 0 from digit branch"));
1a1fdef7 272 digitBranch->GetEntry(0);
273
f95a63c4 274 AliFMDDebug(5, ("Processing digits"));
e802be3e 275 ProcessDigits(digits);
276
8f6ee336 277 Int_t written = clusterTree->Fill();
f95a63c4 278 AliFMDDebug(10, ("Filled %d bytes into cluster tree", written));
0abe7182 279 digits->Delete();
280 delete digits;
4347b38f 281}
1a1fdef7 282
8f6ee336 283
4347b38f 284//____________________________________________________________________
e802be3e 285void
286AliFMDReconstructor::ProcessDigits(TClonesArray* digits) const
4347b38f 287{
69b696b9 288 // For each digit, find the pseudo rapdity, azimuthal angle, and
289 // number of corrected ADC counts, and pass it on to the algorithms
290 // used.
e802be3e 291 Int_t nDigits = digits->GetEntries();
f95a63c4 292 AliFMDDebug(1, ("Got %d digits", nDigits));
a9579262 293 fESDObj->SetNoiseFactor(fNoiseFactor);
294 fESDObj->SetAngleCorrected(fAngleCorrect);
e802be3e 295 for (Int_t i = 0; i < nDigits; i++) {
296 AliFMDDigit* digit = static_cast<AliFMDDigit*>(digits->At(i));
8f6ee336 297 AliFMDParameters* param = AliFMDParameters::Instance();
298 // Check that the strip is not marked as dead
299 if (param->IsDead(digit->Detector(), digit->Ring(),
15b17c89 300 digit->Sector(), digit->Strip())) {
f95a63c4 301 AliFMDDebug(10, ("FMD%d%c[%2d,%3d] is dead", digit->Detector(),
15b17c89 302 digit->Ring(), digit->Sector(), digit->Strip()));
303 continue;
304 }
8f6ee336 305
306 // digit->Print();
307 // Get eta and phi
308 Float_t eta, phi;
309 PhysicalCoordinates(digit, eta, phi);
4347b38f 310
8f6ee336 311 // Substract pedestal.
e802be3e 312 UShort_t counts = SubtractPedestal(digit);
4347b38f 313
8f6ee336 314 // Gain match digits.
315 Double_t edep = Adc2Energy(digit, eta, counts);
316
317 // Make rough multiplicity
318 Double_t mult = Energy2Multiplicity(digit, edep);
319
f95a63c4 320 AliFMDDebug(10, ("FMD%d%c[%2d,%3d]: "
8f6ee336 321 "ADC: %d, Counts: %d, Energy: %f, Mult: %f",
322 digit->Detector(), digit->Ring(), digit->Sector(),
323 digit->Strip(), digit->Counts(), counts, edep, mult));
324
325 // Create a `RecPoint' on the output branch.
bf000c32 326 AliFMDRecPoint* m =
327 new ((*fMult)[fNMult]) AliFMDRecPoint(digit->Detector(),
328 digit->Ring(),
329 digit->Sector(),
330 digit->Strip(),
331 eta, phi,
332 edep, mult);
8f6ee336 333 (void)m; // Suppress warnings about unused variables.
334 fNMult++;
335
336 fESDObj->SetMultiplicity(digit->Detector(), digit->Ring(),
337 digit->Sector(), digit->Strip(), mult);
338 fESDObj->SetEta(digit->Detector(), digit->Ring(),
339 digit->Sector(), digit->Strip(), eta);
9684be2f 340
341 if (fDiagAll) fDiagAll->Fill(digit->Counts(), mult);
4347b38f 342 }
4347b38f 343}
8f6ee336 344
1a1fdef7 345//____________________________________________________________________
346UShort_t
347AliFMDReconstructor::SubtractPedestal(AliFMDDigit* digit) const
348{
349 // Member function to subtract the pedestal from a digit
350 // This implementation does nothing, but a derived class could over
351 // load this to subtract a pedestal that was given in a database or
352 // something like that.
353
8f6ee336 354 Int_t counts = 0;
9684be2f 355 Int_t adc = 0;
8f6ee336 356 AliFMDParameters* param = AliFMDParameters::Instance();
a9579262 357 Float_t ped = param->GetPedestal(digit->Detector(),
8f6ee336 358 digit->Ring(),
359 digit->Sector(),
360 digit->Strip());
a9579262 361 Float_t noise = param->GetPedestalWidth(digit->Detector(),
362 digit->Ring(),
363 digit->Sector(),
364 digit->Strip());
f95a63c4 365 AliFMDDebug(15, ("Subtracting pedestal %f from signal %d",
a9579262 366 ped, digit->Counts()));
9684be2f 367 if (digit->Count3() > 0) adc = digit->Count3();
368 else if (digit->Count2() > 0) adc = digit->Count2();
369 else adc = digit->Count1();
370 counts = TMath::Max(Int_t(adc - ped), 0);
a9579262 371 if (counts < noise * fNoiseFactor) counts = 0;
f95a63c4 372 if (counts > 0) AliFMDDebug(15, ("Got a hit strip"));
9684be2f 373 if (fDiagStep1) fDiagStep1->Fill(adc, counts);
8f6ee336 374
1a1fdef7 375 return UShort_t(counts);
376}
377
4347b38f 378//____________________________________________________________________
8f6ee336 379Float_t
380AliFMDReconstructor::Adc2Energy(AliFMDDigit* digit,
a9579262 381 Float_t eta,
8f6ee336 382 UShort_t count) const
383{
384 // Converts number of ADC counts to energy deposited.
385 // Note, that this member function can be overloaded by derived
386 // classes to do strip-specific look-ups in databases or the like,
387 // to find the proper gain for a strip.
388 //
389 // In this simple version, we calculate the energy deposited as
390 //
391 // EnergyDeposited = cos(theta) * gain * count
392 //
393 // where
394 //
395 // Pre_amp_MIP_Range
396 // gain = ----------------- * Energy_deposited_per_MIP
397 // ADC_channel_size
398 //
399 // is constant and the same for all strips.
a9579262 400 if (count <= 0) return 0;
8f6ee336 401 AliFMDParameters* param = AliFMDParameters::Instance();
402 Float_t gain = param->GetPulseGain(digit->Detector(),
403 digit->Ring(),
404 digit->Sector(),
405 digit->Strip());
f95a63c4 406 AliFMDDebug(15, ("Converting counts %d to energy via factor %f",
8f6ee336 407 count, gain));
a9579262 408
409 Double_t edep = count * gain;
9684be2f 410 if (fDiagStep2) fDiagStep2->Fill(count, edep);
a9579262 411 if (fAngleCorrect) {
9684be2f 412 Double_t theta = 2 * TMath::ATan(TMath::Exp(-eta));
413 Double_t corr = TMath::Abs(TMath::Cos(theta));
414 Double_t cedep = corr * edep;
f95a63c4 415 AliFMDDebug(10, ("correcting for path %f * %f = %f (eta=%f, theta=%f)",
9684be2f 416 edep, corr, cedep, eta, theta));
417 if (fDiagStep3) fDiagStep3->Fill(edep, cedep);
418 edep = cedep;
a9579262 419 }
8f6ee336 420 return edep;
421}
422
423//____________________________________________________________________
424Float_t
425AliFMDReconstructor::Energy2Multiplicity(AliFMDDigit* /* digit */,
426 Float_t edep) const
427{
428 // Converts an energy signal to number of particles.
429 // Note, that this member function can be overloaded by derived
430 // classes to do strip-specific look-ups in databases or the like,
431 // to find the proper gain for a strip.
432 //
433 // In this simple version, we calculate the multiplicity as
434 //
435 // multiplicity = Energy_deposited / Energy_deposited_per_MIP
436 //
437 // where
438 //
439 // Energy_deposited_per_MIP = 1.664 * SI_density * SI_thickness
440 //
441 // is constant and the same for all strips
442 AliFMDParameters* param = AliFMDParameters::Instance();
443 Double_t edepMIP = param->GetEdepMip();
444 Float_t mult = edep / edepMIP;
445 if (edep > 0)
f95a63c4 446 AliFMDDebug(15, ("Translating energy %f to multiplicity via "
8f6ee336 447 "divider %f->%f", edep, edepMIP, mult));
9684be2f 448 if (fDiagStep4) fDiagStep4->Fill(edep, mult);
8f6ee336 449 return mult;
450}
451
452//____________________________________________________________________
453void
454AliFMDReconstructor::PhysicalCoordinates(AliFMDDigit* digit,
455 Float_t& eta,
456 Float_t& phi) const
457{
458 // Get the eta and phi of a digit
459 //
460 // Get geometry.
9b48326f 461 AliFMDGeometry* geom = AliFMDGeometry::Instance();
bf000c32 462 Double_t x, y, z, r, theta;
9b48326f 463 geom->Detector2XYZ(digit->Detector(), digit->Ring(), digit->Sector(),
bf000c32 464 digit->Strip(), x, y, z);
465 // Correct for vertex offset.
466 z += fCurrentVertex;
467 phi = TMath::ATan2(y, x);
468 r = TMath::Sqrt(y * y + x * x);
469 theta = TMath::ATan2(r, z);
470 eta = -TMath::Log(TMath::Tan(theta / 2));
8f6ee336 471}
472
473
474
475//____________________________________________________________________
4347b38f 476void
1a1fdef7 477AliFMDReconstructor::FillESD(TTree* /* digitsTree */,
478 TTree* /* clusterTree */,
af885e0f 479 AliESDEvent* esd) const
121a60bd 480{
42403906 481 // nothing to be done
69b696b9 482 // FIXME: The vertex may not be known when Reconstruct is executed,
483 // so we may have to move some of that member function here.
f95a63c4 484 AliFMDDebug(2, ("Calling FillESD with two trees and one ESD"));
8f6ee336 485 // fESDObj->Print();
486
487 if (esd) {
f95a63c4 488 AliFMDDebug(2, ("Writing FMD data to ESD tree"));
8f6ee336 489 esd->SetFMDData(fESDObj);
a3537838 490 }
9684be2f 491
492 if (!fDiagnostics || !esd) return;
493 static bool first = true;
31fd97b2 494 Int_t evno = esd->GetEventNumberInFile(); // This is most likely NOT the event number you'd like to use. It has nothing to do with the 'real' event number.
f95a63c4 495 AliFMDDebug(1, ("Writing diagnostics histograms to FMD.Diag.root/%03d",
9684be2f 496 evno));
497 TFile f("FMD.Diag.root", (first ? "RECREATE" : "UPDATE"));
498 first = false;
499 f.cd();
500 TDirectory* d = f.mkdir(Form("%03d", evno),
501 Form("Diagnostics histograms for event # %d", evno));
502 d->cd();
503 if (fDiagStep1) fDiagStep1->Write();
504 if (fDiagStep2) fDiagStep2->Write();
505 if (fDiagStep3) fDiagStep3->Write();
506 if (fDiagStep4) fDiagStep4->Write();
507 if (fDiagAll) fDiagAll->Write();
508 d->Write();
509 f.Write();
510 f.Close();
511
512 if (fDiagStep1) fDiagStep1->Reset();
513 if (fDiagStep2) fDiagStep2->Reset();
514 if (fDiagStep3) fDiagStep3->Reset();
515 if (fDiagStep4) fDiagStep4->Reset();
516 if (fDiagAll) fDiagAll->Reset();
121a60bd 517}
518
54e415a8 519
520//____________________________________________________________________
521void
522AliFMDReconstructor::Reconstruct(AliRawReader*,TTree*) const
523{
524 // Cannot be used. See member function with same name but with 2
525 // TTree arguments. Make sure you do local reconstrucion
f95a63c4 526 AliFMDDebug(2, ("Calling FillESD with loader and tree"));
54e415a8 527 AliError("MayNotUse");
528}
529//____________________________________________________________________
530void
531AliFMDReconstructor::Reconstruct(AliRunLoader*) const
532{
533 // Cannot be used. See member function with same name but with 2
534 // TTree arguments. Make sure you do local reconstrucion
f95a63c4 535 AliFMDDebug(2, ("Calling FillESD with loader"));
54e415a8 536 AliError("MayNotUse");
537}
538//____________________________________________________________________
539void
540AliFMDReconstructor::Reconstruct(AliRunLoader*, AliRawReader*) const
541{
542 // Cannot be used. See member function with same name but with 2
543 // TTree arguments. Make sure you do local reconstrucion
f95a63c4 544 AliFMDDebug(2, ("Calling FillESD with loader and raw reader"));
54e415a8 545 AliError("MayNotUse");
546}
547//____________________________________________________________________
548void
af885e0f 549AliFMDReconstructor::FillESD(AliRawReader*,TTree*,AliESDEvent*) const
54e415a8 550{
551 // Cannot be used. See member function with same name but with 2
552 // TTree arguments. Make sure you do local reconstrucion
f95a63c4 553 AliFMDDebug(2, ("Calling FillESD with raw reader, tree, and ESD"));
54e415a8 554 AliError("MayNotUse");
555}
556//____________________________________________________________________
557void
af885e0f 558AliFMDReconstructor::FillESD(AliRunLoader*,AliESDEvent*) const
54e415a8 559{
560 // Cannot be used. See member function with same name but with 2
561 // TTree arguments. Make sure you do local reconstrucion
f95a63c4 562 AliFMDDebug(2, ("Calling FillESD with loader and ESD"));
54e415a8 563 AliError("MayNotUse");
564}
565//____________________________________________________________________
566void
af885e0f 567AliFMDReconstructor::FillESD(AliRunLoader*,AliRawReader*,AliESDEvent*) const
54e415a8 568{
569 // Cannot be used. See member function with same name but with 2
570 // TTree arguments. Make sure you do local reconstrucion
f95a63c4 571 AliFMDDebug(2, ("Calling FillESD with loader, raw reader, and ESD"));
54e415a8 572 AliError("MayNotUse");
573}
574
42403906 575//____________________________________________________________________
576//
577// EOF
578//