Extract ALTRO sample generation to a separate class AliPHOSPulseGenerator
[u/mrichter/AliRoot.git] / PHOS / AliPHOSGetter.cxx
CommitLineData
4ae78bb1 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
803d1ab0 16/* $Id$ */
4ae78bb1 17
18//_________________________________________________________________________
19// A singleton. This class should be used in the analysis stage to get
20// reconstructed objects: Digits, RecPoints, TrackSegments and RecParticles,
21// instead of directly reading them from galice.root file. This container
22// ensures, that one reads Digits, made of these particular digits, RecPoints,
23// made of these particular RecPoints, TrackSegments and RecParticles.
24// This becomes non trivial if there are several identical branches, produced with
25// different set of parameters.
26//
27// An example of how to use (see also class AliPHOSAnalyser):
28// AliPHOSGetter * gime = AliPHOSGetter::GetInstance("galice.root","test") ;
29// for(Int_t irecp = 0; irecp < gime->NRecParticles() ; irecp++)
30// AliPHOSRecParticle * part = gime->RecParticle(1) ;
31// ................
2a657981 32// gime->Event(event) ; // reads new event from galice.root
4ae78bb1 33//
2a657981 34//*-- Author: Yves Schutz (SUBATECH) & Dmitri Peressounko (RRC KI & SUBATECH)
35//*-- Completely redesigned by Dmitri Peressounko March 2001
4ae78bb1 36//
37//*-- YS June 2001 : renamed the original AliPHOSIndexToObject and make
38//*-- systematic usage of TFolders without changing the interface
39//////////////////////////////////////////////////////////////////////////////
40
4ae78bb1 41// --- ROOT system ---
88cb7938 42
d7b234dd 43#include <TFile.h>
44#include <TROOT.h>
45#include <TSystem.h>
46#include <TParticle.h>
a43c51c3 47#include <TF1.h>
e4d04cf1 48#include <TGraph.h>
2bb77d5e 49#include <TCanvas.h>
50#include <TStyle.h>
351dd634 51//#include <TFrame.h>
4ae78bb1 52
53// --- Standard library ---
4ae78bb1 54
55// --- AliRoot header files ---
024a7e64 56#include "AliESD.h"
57#include "AliHeader.h"
58#include "AliMC.h"
e957fea8 59#include "AliPHOS.h"
024a7e64 60#include "AliPHOSBeamTestEvent.h"
61#include "AliPHOSGetter.h"
62#include "AliPHOSLoader.h"
431a9211 63#include "AliPHOSPulseGenerator.h"
88cb7938 64#include "AliRunLoader.h"
65#include "AliStack.h"
d84933b0 66#include "AliCaloRawStream.h"
a43c51c3 67#include "AliRawReaderFile.h"
e4d04cf1 68#include "AliLog.h"
7ca0684e 69#include "AliCDBLocal.h"
70#include "AliCDBStorage.h"
9e1ceb13 71#include "AliCDBManager.h"
88cb7938 72
4ae78bb1 73ClassImp(AliPHOSGetter)
74
2bb77d5e 75AliPHOSGetter * AliPHOSGetter::fgObjGetter = 0 ;
76AliPHOSLoader * AliPHOSGetter::fgPhosLoader = 0;
77AliPHOSCalibData* AliPHOSGetter::fgCalibData = 0;
88cb7938 78Int_t AliPHOSGetter::fgDebug = 0;
79
80// TFile * AliPHOSGetter::fgFile = 0 ;
4ae78bb1 81
3663622c 82AliPHOSGetter::AliPHOSGetter() :
83 fBTE(0),
84 fLoadingStatus(),
85 fNPrimaries(0),
86 fPrimaries(0),
87 fESDFile(0),
88 fESDFileName(),
89 fESD(0),
90 fESDTree(0),
91 fRawDigits(kFALSE),
92 fcdb(0)
93{
94 // ctor: this is a singleton, the ctor should never be called but cint needs it as public
95 Fatal("ctor", "AliPHOSGetter is a singleton default ctor not callable") ;
96}
97
98
4ae78bb1 99//____________________________________________________________________________
3663622c 100AliPHOSGetter::AliPHOSGetter(const char* headerFile, const char* version, Option_t * openingOption) :
101 fBTE(0),
102 fLoadingStatus(),
103 fNPrimaries(0),
104 fPrimaries(0),
105 fESDFile(0),
106 fESDFileName(),
107 fESD(0),
108 fESDTree(0),
109 fRawDigits(kFALSE),
110 fcdb(0)
4ae78bb1 111{
88cb7938 112 // ctor only called by Instance()
dca3a7c4 113
88cb7938 114 AliRunLoader* rl = AliRunLoader::GetRunLoader(version) ;
115 if (!rl) {
116 rl = AliRunLoader::Open(headerFile, version, openingOption);
117 if (!rl) {
118 Fatal("AliPHOSGetter", "Could not find the Run Loader for %s - %s",headerFile, version) ;
119 return ;
120 }
121 if (rl->GetAliRun() == 0x0) {
122 rl->LoadgAlice();
123 gAlice = rl->GetAliRun(); // should be removed
12a7cec1 124 rl->LoadHeader();
7bb289a7 125 }
93aeb834 126 }
88cb7938 127 fgPhosLoader = dynamic_cast<AliPHOSLoader*>(rl->GetLoader("PHOSLoader"));
128 if ( !fgPhosLoader )
129 Error("AliPHOSGetter", "Could not find PHOSLoader") ;
130 else
131 fgPhosLoader->SetTitle(version);
85290134 132
88cb7938 133 // initialize data members
134 SetDebug(0) ;
135 fBTE = 0 ;
136 fPrimaries = 0 ;
137 fLoadingStatus = "" ;
d2713783 138
139 fESDFileName = rl->GetFileName() ; // this should be the galice.root file
140 fESDFileName.ReplaceAll("galice.root", "AliESDs.root") ;
95635748 141 fESDFile = 0 ;
677c8a30 142 fESD = 0 ;
143 fESDTree = 0 ;
66f895c8 144 fRawDigits = kFALSE ;
7ca0684e 145
4ae78bb1 146}
fbf811ec 147
3663622c 148AliPHOSGetter::AliPHOSGetter(const AliPHOSGetter & obj) :
149 TObject(obj),
150 fBTE(0),
151 fLoadingStatus(),
152 fNPrimaries(0),
153 fPrimaries(0),
154 fESDFile(0),
155 fESDFileName(),
156 fESD(0),
157 fESDTree(0),
158 fRawDigits(kFALSE),
159 fcdb(0)
160{
161 // cpy ctor requested by Coding Convention
162 Fatal("cpy ctor", "not implemented") ;
163}
164
165//____________________________________________________________________________
166AliPHOSGetter::AliPHOSGetter(Int_t /*i*/) :
167 fBTE(0),
168 fLoadingStatus(),
169 fNPrimaries(0),
170 fPrimaries(0),
171 fESDFile(0),
172 fESDFileName(),
173 fESD(0),
174 fESDTree(0),
175 fRawDigits(kFALSE),
176 fcdb(0)
177{
178 // special constructor for onflight
179}
180
181
4ae78bb1 182//____________________________________________________________________________
0bc3b8ed 183AliPHOSGetter::~AliPHOSGetter()
184{
185 // dtor
66f895c8 186 if(fgPhosLoader){
187 delete fgPhosLoader ;
188 fgPhosLoader = 0 ;
189 }
190 if(fBTE){
191 delete fBTE ;
192 fBTE = 0 ;
193 }
194 if(fPrimaries){
195 fPrimaries->Delete() ;
196 delete fPrimaries ;
197 }
677c8a30 198 if (fESD)
199 delete fESD ;
200 if (fESDTree)
66f895c8 201 delete fESDTree ;
202
7c193632 203 fgObjGetter = 0;
0ef40383 204}
205
206//____________________________________________________________________________
207void AliPHOSGetter::Reset()
208{
209 // resets things in case the getter is called consecutively with different files
210 // the PHOS Loader is already deleted by the Run Loader
211
212 if (fPrimaries) {
213 fPrimaries->Delete() ;
214 delete fPrimaries ;
215 }
216 fgPhosLoader = 0;
217 fgObjGetter = 0;
65549808 218}
4ae78bb1 219
220//____________________________________________________________________________
88cb7938 221AliPHOSClusterizer * AliPHOSGetter::Clusterizer()
222{
e957fea8 223 // Returns pointer to the Clusterizer task
88cb7938 224 AliPHOSClusterizer * rv ;
225 rv = dynamic_cast<AliPHOSClusterizer *>(PhosLoader()->Reconstructioner()) ;
226 if (!rv) {
227 Event(0, "R") ;
228 rv = dynamic_cast<AliPHOSClusterizer*>(PhosLoader()->Reconstructioner()) ;
0c87da39 229 }
88cb7938 230 return rv ;
0c87da39 231}
232
233//____________________________________________________________________________
2bb77d5e 234TObjArray * AliPHOSGetter::CpvRecPoints() const
4ae78bb1 235{
88cb7938 236 // asks the Loader to return the CPV RecPoints container
237
238 TObjArray * rv = 0 ;
4ae78bb1 239
88cb7938 240 rv = PhosLoader()->CpvRecPoints() ;
241 if (!rv) {
242 PhosLoader()->MakeRecPointsArray() ;
243 rv = PhosLoader()->CpvRecPoints() ;
b134c32f 244 }
88cb7938 245 return rv ;
4ae78bb1 246}
247
248//____________________________________________________________________________
2bb77d5e 249TClonesArray * AliPHOSGetter::Digits() const
4ae78bb1 250{
88cb7938 251 // asks the Loader to return the Digits container
df25f7dd 252
88cb7938 253 TClonesArray * rv = 0 ;
254 rv = PhosLoader()->Digits() ;
7bb289a7 255
88cb7938 256 if( !rv ) {
257 PhosLoader()->MakeDigitsArray() ;
258 rv = PhosLoader()->Digits() ;
fbf811ec 259 }
88cb7938 260 return rv ;
fbf811ec 261}
d489fb96 262
fbf811ec 263//____________________________________________________________________________
88cb7938 264AliPHOSDigitizer * AliPHOSGetter::Digitizer()
265{
e957fea8 266 // Returns pointer to the Digitizer task
88cb7938 267 AliPHOSDigitizer * rv ;
268 rv = dynamic_cast<AliPHOSDigitizer *>(PhosLoader()->Digitizer()) ;
269 if (!rv) {
270 Event(0, "D") ;
271 rv = dynamic_cast<AliPHOSDigitizer *>(PhosLoader()->Digitizer()) ;
48f12df6 272 }
88cb7938 273 return rv ;
4ae78bb1 274}
275
88cb7938 276
4ae78bb1 277//____________________________________________________________________________
2bb77d5e 278TObjArray * AliPHOSGetter::EmcRecPoints() const
6ad0e528 279{
88cb7938 280 // asks the Loader to return the EMC RecPoints container
6ad0e528 281
88cb7938 282 TObjArray * rv = 0 ;
fbf811ec 283
88cb7938 284 rv = PhosLoader()->EmcRecPoints() ;
285 if (!rv) {
286 PhosLoader()->MakeRecPointsArray() ;
287 rv = PhosLoader()->EmcRecPoints() ;
288 }
289 return rv ;
6ad0e528 290}
291
292//____________________________________________________________________________
2bb77d5e 293TClonesArray * AliPHOSGetter::TrackSegments() const
6ad0e528 294{
88cb7938 295 // asks the Loader to return the TrackSegments container
0bc3b8ed 296
88cb7938 297 TClonesArray * rv = 0 ;
6ad0e528 298
88cb7938 299 rv = PhosLoader()->TrackSegments() ;
300 if (!rv) {
301 PhosLoader()->MakeTrackSegmentsArray() ;
302 rv = PhosLoader()->TrackSegments() ;
6ad0e528 303 }
88cb7938 304 return rv ;
6ad0e528 305}
306
307//____________________________________________________________________________
e957fea8 308AliPHOSTrackSegmentMaker * AliPHOSGetter::TrackSegmentMaker()
88cb7938 309{
e957fea8 310 // Returns pointer to the TrackSegmentMaker task
88cb7938 311 AliPHOSTrackSegmentMaker * rv ;
312 rv = dynamic_cast<AliPHOSTrackSegmentMaker *>(PhosLoader()->TrackSegmentMaker()) ;
313 if (!rv) {
314 Event(0, "T") ;
315 rv = dynamic_cast<AliPHOSTrackSegmentMaker *>(PhosLoader()->TrackSegmentMaker()) ;
316 }
7a9d98f9 317 return rv ;
88cb7938 318}
cb34a1fa 319
320//____________________________________________________________________________
2bb77d5e 321TClonesArray * AliPHOSGetter::RecParticles() const
88cb7938 322{
323 // asks the Loader to return the TrackSegments container
cb34a1fa 324
88cb7938 325 TClonesArray * rv = 0 ;
cb34a1fa 326
88cb7938 327 rv = PhosLoader()->RecParticles() ;
328 if (!rv) {
329 PhosLoader()->MakeRecParticlesArray() ;
330 rv = PhosLoader()->RecParticles() ;
cb34a1fa 331 }
88cb7938 332 return rv ;
cb34a1fa 333}
cb34a1fa 334//____________________________________________________________________________
fc7e2f43 335void AliPHOSGetter::Event(Int_t event, const char* opt)
88cb7938 336{
337 // Reads the content of all Tree's S, D and R
dbad285c 338
66f895c8 339// if ( event >= MaxEvent() ) {
340// Error("Event", "%d not found in TreeE !", event) ;
341// return ;
342// }
7a9d98f9 343
88cb7938 344 AliRunLoader * rl = AliRunLoader::GetRunLoader(PhosLoader()->GetTitle());
4ae78bb1 345
66f895c8 346// // checks if we are dealing with test-beam data
347// TBranch * btb = rl->TreeE()->GetBranch("AliPHOSBeamTestEvent") ;
348// if(btb){
349// if(!fBTE)
350// fBTE = new AliPHOSBeamTestEvent() ;
351// btb->SetAddress(&fBTE) ;
352// btb->GetEntry(event) ;
353// }
354// else{
355// if(fBTE){
356// delete fBTE ;
357// fBTE = 0 ;
358// }
359// }
f1611b7c 360
88cb7938 361 // Loads the type of object(s) requested
7a9d98f9 362
88cb7938 363 rl->GetEvent(event) ;
fbf811ec 364
66f895c8 365 if(strstr(opt,"X") || (strcmp(opt,"")==0)){
88cb7938 366 ReadPrimaries() ;
66f895c8 367 }
368
369 if(strstr(opt,"H") ){
88cb7938 370 ReadTreeH();
66f895c8 371 }
372
373 if(strstr(opt,"S") ){
88cb7938 374 ReadTreeS() ;
66f895c8 375 }
376
377 if(strstr(opt,"D") ){
88cb7938 378 ReadTreeD() ;
66f895c8 379 }
380
381 if(strstr(opt,"R") ){
88cb7938 382 ReadTreeR() ;
66f895c8 383 }
b0bba0af 384
66f895c8 385 if( strstr(opt,"T") ){
88cb7938 386 ReadTreeT() ;
66f895c8 387 }
f1611b7c 388
66f895c8 389 if( strstr(opt,"P") ){
88cb7938 390 ReadTreeP() ;
66f895c8 391 }
677c8a30 392
66f895c8 393 if( strstr(opt,"E") ){
677c8a30 394 ReadTreeE(event) ;
3cf4f75f 395 }
396
397}
398
399
400//____________________________________________________________________________
f5eaa851 401void AliPHOSGetter::Event(AliRawReader *rawReader, const char* opt, Bool_t isOldRCUFormat)
3cf4f75f 402{
403 // Reads the raw event from rawReader
f5eaa851 404 // isOldRCUFormat defines whenever to assume
405 // the old RCU format or not
f88e2313 406
3cf4f75f 407 if( strstr(opt,"W") ){
e1c29d81 408 rawReader->NextEvent();
f5eaa851 409 ReadRaw(rawReader,isOldRCUFormat) ;
66f895c8 410 }
95635748 411
b0bba0af 412}
413
7a9d98f9 414
b0bba0af 415//____________________________________________________________________________
88cb7938 416Int_t AliPHOSGetter::EventNumber() const
417 {
418 // return the current event number
419 AliRunLoader * rl = AliRunLoader::GetRunLoader(PhosLoader()->GetTitle());
420 return static_cast<Int_t>(rl->GetEventNumber()) ;
b0bba0af 421}
422
b0bba0af 423//____________________________________________________________________________
2bb77d5e 424 TClonesArray * AliPHOSGetter::Hits() const
88cb7938 425{
426 // asks the loader to return the Hits container
427
428 TClonesArray * rv = 0 ;
b0bba0af 429
88cb7938 430 rv = PhosLoader()->Hits() ;
431 if ( !rv ) {
432 PhosLoader()->LoadHits("read");
433 rv = PhosLoader()->Hits() ;
434 }
435 return rv ;
b0bba0af 436}
548f0134 437
b0bba0af 438//____________________________________________________________________________
88cb7938 439AliPHOSGetter * AliPHOSGetter::Instance(const char* alirunFileName, const char* version, Option_t * openingOption)
440{
441 // Creates and returns the pointer of the unique instance
442 // Must be called only when the environment has changed
443
88cb7938 444 if(!fgObjGetter){ // first time the getter is called
445 fgObjGetter = new AliPHOSGetter(alirunFileName, version, openingOption) ;
446 }
447 else { // the getter has been called previously
448 AliRunLoader * rl = AliRunLoader::GetRunLoader(fgPhosLoader->GetTitle());
449 if ( rl->GetFileName() == alirunFileName ) {// the alirunFile has the same name
450 // check if the file is already open
451 TFile * galiceFile = dynamic_cast<TFile *>(gROOT->FindObject(rl->GetFileName()) ) ;
452
453 if ( !galiceFile )
454 fgObjGetter = new AliPHOSGetter(alirunFileName, version, openingOption) ;
455
456 else { // the file is already open check the version name
457 TString currentVersionName = rl->GetEventFolder()->GetName() ;
458 TString newVersionName(version) ;
459 if (currentVersionName == newVersionName)
460 if(fgDebug)
461 ::Warning( "Instance", "Files with version %s already open", currentVersionName.Data() ) ;
462 else {
463 fgObjGetter = new AliPHOSGetter(alirunFileName, version, openingOption) ;
464 }
465 }
7a9d98f9 466 }
7fba1747 467 else {
468 AliRunLoader * rl = AliRunLoader::GetRunLoader(fgPhosLoader->GetTitle()) ;
e191bb57 469 if ( strstr(version, AliConfig::GetDefaultEventFolderName()) ) // false in case of merging
1c221c70 470 delete rl ;
88cb7938 471 fgObjGetter = new AliPHOSGetter(alirunFileName, version, openingOption) ;
7fba1747 472 }
b0bba0af 473 }
88cb7938 474 if (!fgObjGetter)
95635748 475 ::Error("AliPHOSGetter::Instance", "Failed to create the PHOS Getter object") ;
88cb7938 476 else
477 if (fgDebug)
478 Print() ;
479
480 return fgObjGetter ;
b0bba0af 481}
7a9d98f9 482
b0bba0af 483//____________________________________________________________________________
88cb7938 484AliPHOSGetter * AliPHOSGetter::Instance()
0bc3b8ed 485{
88cb7938 486 // Returns the pointer of the unique instance already defined
b0bba0af 487
95635748 488 if(!fgObjGetter && fgDebug)
489 ::Warning("AliPHOSGetter::Instance", "Getter not initialized") ;
b0bba0af 490
88cb7938 491 return fgObjGetter ;
492
b0bba0af 493}
494
b0bba0af 495//____________________________________________________________________________
88cb7938 496Int_t AliPHOSGetter::MaxEvent() const
0bc3b8ed 497{
88cb7938 498 // returns the number of events in the run (from TE)
7a9d98f9 499
88cb7938 500 AliRunLoader * rl = AliRunLoader::GetRunLoader(PhosLoader()->GetTitle());
501 return static_cast<Int_t>(rl->GetNumberOfEvents()) ;
502}
7a9d98f9 503
b0bba0af 504//____________________________________________________________________________
88cb7938 505TParticle * AliPHOSGetter::Primary(Int_t index) const
0bc3b8ed 506{
88cb7938 507 AliRunLoader * rl = AliRunLoader::GetRunLoader(PhosLoader()->GetTitle());
508 return rl->Stack()->Particle(index) ;
7a9d98f9 509}
b0bba0af 510
b0bba0af 511//____________________________________________________________________________
88cb7938 512AliPHOS * AliPHOSGetter:: PHOS() const
513{
514 // returns the PHOS object
5c4bcd63 515 AliPHOSLoader * loader = 0;
516 static AliPHOSLoader * oldloader = 0;
517 static AliPHOS * phos = 0;
518
519 loader = PhosLoader();
520
521 if ( loader != oldloader) {
522 phos = dynamic_cast<AliPHOS*>(loader->GetModulesFolder()->FindObject("PHOS")) ;
523 oldloader = loader;
524 }
88cb7938 525 if (!phos)
526 if (fgDebug)
527 Warning("PHOS", "PHOS module not found in module folders: %s", PhosLoader()->GetModulesFolder()->GetName() ) ;
528 return phos ;
529}
b0bba0af 530
b0bba0af 531
b0bba0af 532
b0bba0af 533//____________________________________________________________________________
e957fea8 534AliPHOSPID * AliPHOSGetter::PID()
88cb7938 535{
e957fea8 536 // Returns pointer to the PID task
88cb7938 537 AliPHOSPID * rv ;
538 rv = dynamic_cast<AliPHOSPID *>(PhosLoader()->PIDTask()) ;
539 if (!rv) {
540 Event(0, "P") ;
541 rv = dynamic_cast<AliPHOSPID *>(PhosLoader()->PIDTask()) ;
b0bba0af 542 }
88cb7938 543 return rv ;
b0bba0af 544}
545
546//____________________________________________________________________________
88cb7938 547AliPHOSGeometry * AliPHOSGetter::PHOSGeometry() const
548{
549 // Returns PHOS geometry
7a9d98f9 550
88cb7938 551 AliPHOSGeometry * rv = 0 ;
552 if (PHOS() )
553 rv = PHOS()->GetGeometry() ;
52c5f046 554 else {
555 rv = AliPHOSGeometry::GetInstance();
556 if (!rv) {
557 AliError("Could not find PHOS geometry! Loading the default one !");
558 rv = AliPHOSGeometry::GetInstance("IHEP","");
559 }
560 }
88cb7938 561 return rv ;
7a9d98f9 562}
b0bba0af 563
564//____________________________________________________________________________
88cb7938 565TClonesArray * AliPHOSGetter::Primaries()
0bc3b8ed 566{
88cb7938 567 // creates the Primaries container if needed
568 if ( !fPrimaries ) {
569 if (fgDebug)
570 Info("Primaries", "Creating a new TClonesArray for primaries") ;
571 fPrimaries = new TClonesArray("TParticle", 1000) ;
572 }
573 return fPrimaries ;
b0bba0af 574}
575
576//____________________________________________________________________________
88cb7938 577void AliPHOSGetter::Print()
578{
579 // Print usefull information about the getter
580
581 AliRunLoader * rl = AliRunLoader::GetRunLoader(fgPhosLoader->GetTitle());
582 ::Info( "Print", "gAlice file is %s -- version name is %s", (rl->GetFileName()).Data(), rl->GetEventFolder()->GetName() ) ;
b0bba0af 583}
7a9d98f9 584
b0bba0af 585//____________________________________________________________________________
88cb7938 586void AliPHOSGetter::ReadPrimaries()
587{
588 // Read Primaries from Kinematics.root
b0bba0af 589
88cb7938 590 AliRunLoader * rl = AliRunLoader::GetRunLoader(PhosLoader()->GetTitle());
7a9d98f9 591
88cb7938 592 // gets kine tree from the root file (Kinematics.root)
7fba1747 593 if ( ! rl->TreeK() ) { // load treeK the first time
88cb7938 594 rl->LoadKinematics() ;
7fba1747 595 }
7a9d98f9 596
7fba1747 597 fNPrimaries = (rl->GetHeader())->GetNtrack();
88cb7938 598 if (fgDebug)
599 Info( "ReadTreeK", "Found %d particles in event # %d", fNPrimaries, EventNumber() ) ;
7a9d98f9 600
7a9d98f9 601
88cb7938 602 // first time creates the container
603 if ( Primaries() )
604 fPrimaries->Clear() ;
b0bba0af 605
88cb7938 606 Int_t index = 0 ;
607 for (index = 0 ; index < fNPrimaries; index++) {
608 new ((*fPrimaries)[index]) TParticle(*(Primary(index)));
b0bba0af 609 }
88cb7938 610}
7a9d98f9 611
b0bba0af 612//____________________________________________________________________________
d2713783 613Bool_t AliPHOSGetter::OpenESDFile()
95635748 614{
d2713783 615 //Open the ESD file
95635748 616 Bool_t rv = kTRUE ;
d2713783 617 if (!fESDFile) {
618 fESDFile = TFile::Open(fESDFileName) ;
619 if (!fESDFile )
620 return kFALSE ;
621 }
95635748 622 else if (fESDFile->IsOpen()) {
623 fESDFile->Close() ;
624 fESDFile = TFile::Open(fESDFileName) ;
625 }
626 if (!fESDFile->IsOpen())
627 rv = kFALSE ;
628 return rv ;
629}
630
631//____________________________________________________________________________
2bb77d5e 632void AliPHOSGetter::FitRaw(Bool_t lowGainFlag, TGraph * gLowGain, TGraph * gHighGain, TF1* signalF, Double_t & energy, Double_t & time) const
45c1ce6f 633{
634 // Fits the raw signal time distribution
635
636 const Int_t kNoiseThreshold = 0 ;
637 Double_t timezero1 = 0., timezero2 = 0., timemax = 0. ;
638 Double_t signal = 0., signalmax = 0. ;
44ae287e 639 time = 0. ;
640 energy = 0. ;
45c1ce6f 641
431a9211 642 // Create a shaper pulse object which contains all the shaper parameters
643 AliPHOSPulseGenerator *pulse = new AliPHOSPulseGenerator();
644
45c1ce6f 645 if (lowGainFlag) {
646 timezero1 = timezero2 = signalmax = timemax = 0. ;
431a9211 647 signalF->FixParameter(0, pulse->GetRawFormatLowCharge()) ;
648 signalF->FixParameter(1, pulse->GetRawFormatLowGain()) ;
45c1ce6f 649 Int_t index ;
431a9211 650 for (index = 0; index < pulse->GetRawFormatTimeBins(); index++) {
45c1ce6f 651 gLowGain->GetPoint(index, time, signal) ;
652 if (signal > kNoiseThreshold && timezero1 == 0.)
653 timezero1 = time ;
654 if (signal <= kNoiseThreshold && timezero1 > 0. && timezero2 == 0.)
655 timezero2 = time ;
656 if (signal > signalmax) {
657 signalmax = signal ;
658 timemax = time ;
659 }
660 }
431a9211 661 signalmax /=
662 pulse->RawResponseFunctionMax(pulse->GetRawFormatLowCharge(),
663 pulse->GetRawFormatLowGain()) ;
664 if ( timezero1 + pulse->GetRawFormatTimePeak() < pulse->GetRawFormatTimeMax() * 0.4 ) { // else its noise
45c1ce6f 665 signalF->SetParameter(2, signalmax) ;
666 signalF->SetParameter(3, timezero1) ;
2bb77d5e 667 gLowGain->Fit(signalF, "QRO", "", 0., timezero2); //, "QRON") ;
45c1ce6f 668 energy = signalF->GetParameter(2) ;
431a9211 669 time = signalF->GetMaximumX() - pulse->GetRawFormatTimePeak() - pulse->GetRawFormatTimeTrigger() ;
45c1ce6f 670 }
671 } else {
672 timezero1 = timezero2 = signalmax = timemax = 0. ;
431a9211 673 signalF->FixParameter(0, pulse->GetRawFormatHighCharge()) ;
674 signalF->FixParameter(1, pulse->GetRawFormatHighGain()) ;
45c1ce6f 675 Int_t index ;
431a9211 676 for (index = 0; index < pulse->GetRawFormatTimeBins(); index++) {
45c1ce6f 677 gHighGain->GetPoint(index, time, signal) ;
678 if (signal > kNoiseThreshold && timezero1 == 0.)
679 timezero1 = time ;
680 if (signal <= kNoiseThreshold && timezero1 > 0. && timezero2 == 0.)
681 timezero2 = time ;
682 if (signal > signalmax) {
683 signalmax = signal ;
684 timemax = time ;
685 }
686 }
431a9211 687 signalmax /= pulse->RawResponseFunctionMax(pulse->GetRawFormatHighCharge(),
688 pulse->GetRawFormatHighGain()) ;;
689 if ( timezero1 + pulse->GetRawFormatTimePeak() < pulse->GetRawFormatTimeMax() * 0.4 ) { // else its noise
45c1ce6f 690 signalF->SetParameter(2, signalmax) ;
691 signalF->SetParameter(3, timezero1) ;
2bb77d5e 692 gHighGain->Fit(signalF, "QRO", "", 0., timezero2) ;
45c1ce6f 693 energy = signalF->GetParameter(2) ;
431a9211 694 time = signalF->GetMaximumX() - pulse->GetRawFormatTimePeak() - pulse->GetRawFormatTimeTrigger() ;
45c1ce6f 695 }
696 }
44ae287e 697 if (time == 0) energy = 0 ;
45c1ce6f 698}
699
700//____________________________________________________________________________
44ae287e 701Int_t AliPHOSGetter::CalibrateRaw(Double_t energy, Int_t *relId)
702{
703 // Convert energy into digitized amplitude for a cell relId
704 // It is a user responsilibity to open CDB and set
705 // AliPHOSCalibData object by the following operators:
706 //
707 // AliCDBLocal *loc = new AliCDBLocal("deCalibDB");
708 // AliPHOSCalibData* clb = (AliPHOSCalibData*)AliCDBStorage::Instance()
709 // ->Get(path_to_calibdata,run_number);
710 // AliPHOSGetter* gime = AliPHOSGetter::Instance("galice.root");
711 // gime->SetCalibData(clb);
712
713 if (CalibData() == 0)
f88e2313 714 Warning("CalibrateRaw","Calibration DB is not initiated!");
44ae287e 715
716 Int_t module = relId[0];
f88e2313 717 Int_t column = relId[3];
718 Int_t row = relId[2];
719
720 Float_t gainFactor = 0.0015; // width of one Emc ADC channel in GeV
721 Float_t pedestal = 0.005; // Emc pedestals
722
723 if(CalibData()) {
724 gainFactor = CalibData()->GetADCchannelEmc (module,column,row);
725 pedestal = CalibData()->GetADCpedestalEmc(module,column,row);
726 }
727
44ae287e 728 Int_t amp = static_cast<Int_t>( (energy - pedestal) / gainFactor + 0.5 ) ;
729 return amp;
730}
731//____________________________________________________________________________
f5eaa851 732Int_t AliPHOSGetter::ReadRaw(AliRawReader *rawReader,Bool_t isOldRCUFormat)
a43c51c3 733{
734 // reads the raw format data, converts it into digits format and store digits in Digits()
735 // container.
f5eaa851 736 // isOldRCUFormat = kTRUE in case of the old RCU
02e48b45 737 // format used in the raw data readout.
738 // Reimplemented by Boris Polichtchouk (Jul 2006)
739 // to make it working with the Jul-Aug 2006 beam test data.
740
d84933b0 741 AliCaloRawStream in(rawReader,"PHOS");
f5eaa851 742 in.SetOldRCUFormat(isOldRCUFormat);
a43c51c3 743
431a9211 744 // Create a shaper pulse object
745 AliPHOSPulseGenerator *pulse = new AliPHOSPulseGenerator();
746 TF1 * signalF = new TF1("signal", AliPHOSPulseGenerator::RawResponseFunction, 0, pulse->GetRawFormatTimeMax(), 4);
45c1ce6f 747 signalF->SetParNames("Charge", "Gain", "Amplitude", "TimeZero") ;
748
6a0d2265 749 Int_t relId[4], absId =0;
45c1ce6f 750 Bool_t lowGainFlag = kFALSE ;
2bb77d5e 751
a43c51c3 752 TClonesArray * digits = Digits() ;
02e48b45 753 digits->Clear() ;
754
6a0d2265 755 Int_t iBin = 0;
756 Int_t iDigit = 0 ;
69464fdb 757 Double_t energyHG = 0. ;
758 Double_t energyLG = 0. ;
6a0d2265 759 Double_t time = 0. ;
760 Int_t iOldDigit;
761 Bool_t seen;
762 TH1F* hLowGain = 0;
763 TH1F* hHighGain = 0;
19309784 764
45c1ce6f 765 while ( in.Next() ) { // PHOS entries loop
02e48b45 766
767 lowGainFlag = in.IsLowGain();
6a0d2265 768
769 // (Re)create histograms to store samples
770
771 if (lowGainFlag) {
772 if(!hLowGain)
773 hLowGain = new TH1F("hLowGain","Low gain",in.GetTimeLength(),0,in.GetTimeLength());
774 else
775 if(hLowGain->GetNbinsX() != in.GetTimeLength()) {
776 delete hLowGain;
777 hLowGain = new TH1F("hLowGain","Low gain",in.GetTimeLength(),0,in.GetTimeLength());
778 }
779 } else {
780 if(!hHighGain)
781 hHighGain = new TH1F("hHighGain","High gain",in.GetTimeLength(),0,in.GetTimeLength());
782 else
783 if(hHighGain->GetNbinsX() != in.GetTimeLength()) {
784 delete hHighGain;
785 hHighGain = new TH1F("hHighGain","High gain",in.GetTimeLength(),0,in.GetTimeLength());
786 }
787 }
788
789 // Fill histograms with samples
02e48b45 790 if(lowGainFlag)
6a0d2265 791 hLowGain ->SetBinContent(in.GetTimeLength()-iBin-1,in.GetSignal());
c89c49ca 792 else {
6a0d2265 793 hHighGain->SetBinContent(in.GetTimeLength()-iBin-1,in.GetSignal());
c89c49ca 794 }
19309784 795
02e48b45 796 iBin++;
797
6a0d2265 798 // Fit the full sample
02e48b45 799 if(iBin==in.GetTimeLength()) {
800 iBin=0;
801
02e48b45 802 // Temporarily we do not fit the sample graph, but
803 // take the energy from the graph maximum, and the pedestal from the 0th point
804 // 30 Aug 2006
69464fdb 805
6a0d2265 806 //FitRaw(lowGainFlag, hLowGain, hHighGain, signalF, energy, time);
69464fdb 807
6a0d2265 808 if(lowGainFlag) {
809 energyLG = hLowGain ->GetMaximum(); // "digit amplitude"
810// energyLG -= hLowGain ->GetBinContent(0); // "pedestal subtraction"
431a9211 811 energyLG *= pulse->GetRawFormatHighLowGainFactor(); // *16
6a0d2265 812 if(AliLog::GetGlobalDebugLevel()>3)
813 AliDebug(4,Form("----Printing hLowGain: ----\n")) ; hLowGain ->Print("all");
814 AliDebug(2,Form("AliPHOSGetter::ReadRaw: (mod,col,row)=(%d,%d,%d), low gain energy=%f\n\n",
815 in.GetModule(),in.GetColumn(),in.GetRow(),energyLG));
816 }
817
818 else {
819 energyHG = hHighGain->GetMaximum(); // "digit amplitude"
820// energyHG -= hHighGain->GetBinContent(0); // "pedestal subtraction"
821 if(AliLog::GetGlobalDebugLevel()>3)
822 AliDebug(4,Form("----Printing hHighGain: ----\n")); hHighGain->Print("all");
823 AliDebug(2,Form("AliPHOSGetter::ReadRaw: (mod,col,row)=(%d,%d,%d), high gain energy=%f\n\n",
824 in.GetModule(),in.GetColumn(),in.GetRow(),energyHG));
45c1ce6f 825 }
69464fdb 826
6a0d2265 827 // Time is not evaluated for the moment (12.01.2007). To be implemented later.
02e48b45 828 time = -1;
829
69464fdb 830 relId[0] = in.GetModule()+1;
02e48b45 831 relId[1] = 0;
832 relId[2] = in.GetRow();
833 relId[3] = in.GetColumn();
6a0d2265 834 if(!PHOSGeometry()) AliFatal("Couldn't find PHOSGeometry!");
835 PHOSGeometry()->RelToAbsNumbering(relId, absId);
836
837 // Add low gain digit only if the high gain digit does not exist in the digits array
838 if(lowGainFlag) {
839 seen = kFALSE;
840 for (iOldDigit=iDigit; iOldDigit=0; iOldDigit--) {
841 if (dynamic_cast<AliPHOSDigit*>(digits->At(iOldDigit))->GetId() == absId) {
842 seen = kTRUE;
843 break;
844 }
845 }
846 if (!seen)
847 new((*digits)[iDigit]) AliPHOSDigit(-1,absId,(Float_t)energyLG,time);
848 energyLG = 0. ;
69464fdb 849 }
eef8bd53 850 // Add high gain digit only if it is not saturated;
851 // replace low gain digit by a high gain one
69464fdb 852 else {
eef8bd53 853 if (energyHG >= 1023) continue;
6a0d2265 854 for (iOldDigit=iDigit; iOldDigit=0; iOldDigit--) {
855 if (dynamic_cast<AliPHOSDigit*>(digits->At(iOldDigit))->GetId() == absId) {
eef8bd53 856 digits->RemoveAt(iOldDigit);
857 new((*digits)[iDigit]) AliPHOSDigit(-1,absId,(Float_t)energyHG,time);
6a0d2265 858 break;
859 }
860 }
6a0d2265 861 energyHG = 0. ;
02e48b45 862 }
6a0d2265 863 iDigit++;
66f895c8 864 }
44ae287e 865 }
45c1ce6f 866
02e48b45 867 // PHOS entries loop
868
869 digits->Sort() ;
69464fdb 870
871 //!!!!for debug!!!
872 Int_t modMax=-111;
873 Int_t colMax=-111;
874 Int_t rowMax=-111;
875 Float_t eMax=-333;
876 //!!!for debug!!!
877
6a0d2265 878 for(iDigit=0; iDigit<digits->GetEntries(); iDigit++) {
69464fdb 879 AliPHOSDigit* digit = (AliPHOSDigit*)digits->At(iDigit);
880 if(digit->GetEnergy()>eMax) {
881 PHOSGeometry()->AbsToRelNumbering(digit->GetId(),relId);
882 eMax=digit->GetEnergy();
883 modMax=relId[0];
884 rowMax=relId[2];
885 colMax=relId[3];
886 }
887 }
19309784 888
6a0d2265 889 AliDebug(1,Form("Digit with max. energy: modMax %d colMax %d rowMax %d eMax %f\n\n",
890 modMax,colMax,rowMax,eMax));
69464fdb 891
19309784 892 delete signalF ;
6a0d2265 893 delete hHighGain;
894 delete hLowGain;
02e48b45 895
e4d04cf1 896 return digits->GetEntriesFast() ;
a43c51c3 897}
45c1ce6f 898
a43c51c3 899//____________________________________________________________________________
fd31ff92 900Int_t AliPHOSGetter::ReadTreeD() const
88cb7938 901{
902 // Read the Digits
7a9d98f9 903
41c29fde 904 PhosLoader()->CleanDigits() ;
ff808dc7 905 PhosLoader()->LoadDigits("UPDATE") ;
906 PhosLoader()->LoadDigitizer("UPDATE") ;
88cb7938 907 return Digits()->GetEntries() ;
908}
7a9d98f9 909
b0bba0af 910//____________________________________________________________________________
fd31ff92 911Int_t AliPHOSGetter::ReadTreeH() const
0bc3b8ed 912{
88cb7938 913 // Read the Hits
41c29fde 914 PhosLoader()->CleanHits() ;
88cb7938 915 // gets TreeH from the root file (PHOS.Hit.root)
41c29fde 916 //if ( !IsLoaded("H") ) {
88cb7938 917 PhosLoader()->LoadHits("UPDATE") ;
41c29fde 918 // SetLoaded("H") ;
919 //}
88cb7938 920 return Hits()->GetEntries() ;
921}
b0bba0af 922
923//____________________________________________________________________________
fd31ff92 924Int_t AliPHOSGetter::ReadTreeR() const
88cb7938 925{
926 // Read the RecPoints
b0bba0af 927
41c29fde 928 PhosLoader()->CleanRecPoints() ;
88cb7938 929 // gets TreeR from the root file (PHOS.RecPoints.root)
41c29fde 930 //if ( !IsLoaded("R") ) {
88cb7938 931 PhosLoader()->LoadRecPoints("UPDATE") ;
932 PhosLoader()->LoadClusterizer("UPDATE") ;
41c29fde 933 // SetLoaded("R") ;
934 //}
7a9d98f9 935
88cb7938 936 return EmcRecPoints()->GetEntries() ;
7bb289a7 937}
88cb7938 938
7bb289a7 939//____________________________________________________________________________
fd31ff92 940Int_t AliPHOSGetter::ReadTreeT() const
0bc3b8ed 941{
88cb7938 942 // Read the TrackSegments
7a9d98f9 943
41c29fde 944 PhosLoader()->CleanTracks() ;
88cb7938 945 // gets TreeT from the root file (PHOS.TrackSegments.root)
41c29fde 946 //if ( !IsLoaded("T") ) {
88cb7938 947 PhosLoader()->LoadTracks("UPDATE") ;
948 PhosLoader()->LoadTrackSegmentMaker("UPDATE") ;
41c29fde 949 // SetLoaded("T") ;
950 //}
7a9d98f9 951
88cb7938 952 return TrackSegments()->GetEntries() ;
953}
b0bba0af 954//____________________________________________________________________________
fd31ff92 955Int_t AliPHOSGetter::ReadTreeP() const
0bc3b8ed 956{
41c29fde 957 // Read the RecParticles
b0bba0af 958
41c29fde 959 PhosLoader()->CleanRecParticles() ;
960
88cb7938 961 // gets TreeT from the root file (PHOS.TrackSegments.root)
41c29fde 962 // if ( !IsLoaded("P") ) {
88cb7938 963 PhosLoader()->LoadRecParticles("UPDATE") ;
964 PhosLoader()->LoadPID("UPDATE") ;
41c29fde 965 // SetLoaded("P") ;
966 //}
b0bba0af 967
88cb7938 968 return RecParticles()->GetEntries() ;
4ae78bb1 969}
4ae78bb1 970//____________________________________________________________________________
fd31ff92 971Int_t AliPHOSGetter::ReadTreeS() const
88cb7938 972{
973 // Read the SDigits
7a9d98f9 974
41c29fde 975 PhosLoader()->CleanSDigits() ;
88cb7938 976 // gets TreeS from the root file (PHOS.SDigits.root)
41c29fde 977 //if ( !IsLoaded("S") ) {
7b4c1168 978 PhosLoader()->LoadSDigits("READ") ;
979 PhosLoader()->LoadSDigitizer("READ") ;
41c29fde 980 // SetLoaded("S") ;
981 //}
7a9d98f9 982
88cb7938 983 return SDigits()->GetEntries() ;
9bd3caba 984}
985
986//____________________________________________________________________________
677c8a30 987Int_t AliPHOSGetter::ReadTreeE(Int_t event)
988{
989 // Read the ESD
990
991 // gets esdTree from the root file (AliESDs.root)
992 if (!fESDFile)
993 if ( !OpenESDFile() )
994 return -1 ;
995
996 fESDTree = static_cast<TTree*>(fESDFile->Get("esdTree")) ;
997 fESD = new AliESD;
998 if (!fESDTree) {
999
1000 Error("ReadTreeE", "no ESD tree found");
1001 return -1;
1002 }
1003 fESDTree->SetBranchAddress("ESD", &fESD);
1004 fESDTree->GetEvent(event);
1005
1006 return event ;
1007}
1008
1009//____________________________________________________________________________
2bb77d5e 1010TClonesArray * AliPHOSGetter::SDigits() const
9bd3caba 1011{
88cb7938 1012 // asks the Loader to return the Digits container
9bd3caba 1013
88cb7938 1014 TClonesArray * rv = 0 ;
9bd3caba 1015
88cb7938 1016 rv = PhosLoader()->SDigits() ;
1017 if (!rv) {
1018 PhosLoader()->MakeSDigitsArray() ;
1019 rv = PhosLoader()->SDigits() ;
9bd3caba 1020 }
88cb7938 1021 return rv ;
9bd3caba 1022}
1023
7a9d98f9 1024//____________________________________________________________________________
e957fea8 1025AliPHOSSDigitizer * AliPHOSGetter::SDigitizer()
88cb7938 1026{
e957fea8 1027 // Returns pointer to the SDigitizer task
88cb7938 1028 AliPHOSSDigitizer * rv ;
1029 rv = dynamic_cast<AliPHOSSDigitizer *>(PhosLoader()->SDigitizer()) ;
1030 if (!rv) {
1031 Event(0, "S") ;
1032 rv = dynamic_cast<AliPHOSSDigitizer *>(PhosLoader()->SDigitizer()) ;
9bd3caba 1033 }
88cb7938 1034 return rv ;
4ae78bb1 1035}
1036
1037//____________________________________________________________________________
fc7e2f43 1038TParticle * AliPHOSGetter::Secondary(const TParticle* p, Int_t index) const
cb34a1fa 1039{
1040 // Return first (index=1) or second (index=2) secondary particle of primary particle p
1041
1042 if(index <= 0)
1043 return 0 ;
1044 if(index > 2)
1045 return 0 ;
1046
1047 if(p) {
1048 Int_t daughterIndex = p->GetDaughter(index-1) ;
88cb7938 1049 AliRunLoader * rl = AliRunLoader::GetRunLoader(PhosLoader()->GetTitle());
5d12ce38 1050 return rl->GetAliRun()->GetMCApp()->Particle(daughterIndex) ;
cb34a1fa 1051 }
1052 else
1053 return 0 ;
1054}
1055
1056//____________________________________________________________________________
fc7e2f43 1057void AliPHOSGetter::Track(Int_t itrack)
b0bba0af 1058{
1059 // Read the first entry of PHOS branch in hit tree gAlice->TreeH()
7a9d98f9 1060
88cb7938 1061 AliRunLoader * rl = AliRunLoader::GetRunLoader(PhosLoader()->GetTitle());
4ae78bb1 1062
88cb7938 1063 if( !TreeH() ) // load treeH the first time
1064 rl->LoadHits() ;
59b46416 1065
88cb7938 1066 // first time create the container
1067 TClonesArray * hits = Hits() ;
1068 if ( hits )
1069 hits->Clear() ;
fbf811ec 1070
88cb7938 1071 TBranch * phosbranch = dynamic_cast<TBranch*>(TreeH()->GetBranch("PHOS")) ;
1072 phosbranch->SetAddress(&hits) ;
1073 phosbranch->GetEntry(itrack) ;
4ae78bb1 1074}
1075
1076//____________________________________________________________________________
88cb7938 1077TTree * AliPHOSGetter::TreeD() const
4ae78bb1 1078{
e957fea8 1079 // Returns pointer to the Digits Tree
88cb7938 1080 TTree * rv = 0 ;
1081 rv = PhosLoader()->TreeD() ;
1082 if ( !rv ) {
1083 PhosLoader()->MakeTree("D");
1084 rv = PhosLoader()->TreeD() ;
1085 }
b0bba0af 1086
88cb7938 1087 return rv ;
b0bba0af 1088}
548f0134 1089
b0bba0af 1090//____________________________________________________________________________
88cb7938 1091TTree * AliPHOSGetter::TreeH() const
0bc3b8ed 1092{
e957fea8 1093 // Returns pointer to the Hits Tree
88cb7938 1094 TTree * rv = 0 ;
1095 rv = PhosLoader()->TreeH() ;
1096 if ( !rv ) {
1097 PhosLoader()->MakeTree("H");
1098 rv = PhosLoader()->TreeH() ;
7a9d98f9 1099 }
4ae78bb1 1100
88cb7938 1101 return rv ;
4ae78bb1 1102}
1103
1104//____________________________________________________________________________
88cb7938 1105TTree * AliPHOSGetter::TreeR() const
4ae78bb1 1106{
e957fea8 1107 // Returns pointer to the RecPoints Tree
88cb7938 1108 TTree * rv = 0 ;
1109 rv = PhosLoader()->TreeR() ;
1110 if ( !rv ) {
1111 PhosLoader()->MakeTree("R");
1112 rv = PhosLoader()->TreeR() ;
1113 }
b0bba0af 1114
88cb7938 1115 return rv ;
4ae78bb1 1116}
65549808 1117
1118//____________________________________________________________________________
88cb7938 1119TTree * AliPHOSGetter::TreeT() const
65549808 1120{
e957fea8 1121 // Returns pointer to the TrackSegments Tree
88cb7938 1122 TTree * rv = 0 ;
1123 rv = PhosLoader()->TreeT() ;
1124 if ( !rv ) {
1125 PhosLoader()->MakeTree("T");
1126 rv = PhosLoader()->TreeT() ;
1127 }
b134c32f 1128
88cb7938 1129 return rv ;
65549808 1130}
65549808 1131//____________________________________________________________________________
88cb7938 1132TTree * AliPHOSGetter::TreeP() const
65549808 1133{
e957fea8 1134 // Returns pointer to the RecParticles Tree
88cb7938 1135 TTree * rv = 0 ;
1136 rv = PhosLoader()->TreeP() ;
1137 if ( !rv ) {
1138 PhosLoader()->MakeTree("P");
1139 rv = PhosLoader()->TreeP() ;
1140 }
65549808 1141
88cb7938 1142 return rv ;
65549808 1143}
1144
1145//____________________________________________________________________________
88cb7938 1146TTree * AliPHOSGetter::TreeS() const
e957fea8 1147{
1148 // Returns pointer to the SDigits Tree
88cb7938 1149 TTree * rv = 0 ;
1150 rv = PhosLoader()->TreeS() ;
1151 if ( !rv ) {
1152 PhosLoader()->MakeTree("S");
1153 rv = PhosLoader()->TreeS() ;
1154 }
65549808 1155
88cb7938 1156 return rv ;
65549808 1157}
fbf811ec 1158
1159//____________________________________________________________________________
88cb7938 1160Bool_t AliPHOSGetter::VersionExists(TString & opt) const
0bc3b8ed 1161{
88cb7938 1162 // checks if the version with the present name already exists in the same directory
fbf811ec 1163
88cb7938 1164 Bool_t rv = kFALSE ;
1165
1166 AliRunLoader * rl = AliRunLoader::GetRunLoader(PhosLoader()->GetTitle());
1167 TString version( rl->GetEventFolder()->GetName() ) ;
fbf811ec 1168
88cb7938 1169 opt.ToLower() ;
fbf811ec 1170
88cb7938 1171 if ( opt == "sdigits") {
1172 // add the version name to the root file name
1173 TString fileName( PhosLoader()->GetSDigitsFileName() ) ;
e191bb57 1174 if (version != AliConfig::GetDefaultEventFolderName()) // only if not the default folder name
88cb7938 1175 fileName = fileName.ReplaceAll(".root", "") + "_" + version + ".root" ;
1176 if ( !(gSystem->AccessPathName(fileName)) ) {
1177 Warning("VersionExists", "The file %s already exists", fileName.Data()) ;
1178 rv = kTRUE ;
fbf811ec 1179 }
88cb7938 1180 PhosLoader()->SetSDigitsFileName(fileName) ;
fbf811ec 1181 }
fbf811ec 1182
88cb7938 1183 if ( opt == "digits") {
1184 // add the version name to the root file name
1185 TString fileName( PhosLoader()->GetDigitsFileName() ) ;
e191bb57 1186 if (version != AliConfig::GetDefaultEventFolderName()) // only if not the default folder name
88cb7938 1187 fileName = fileName.ReplaceAll(".root", "") + "_" + version + ".root" ;
1188 if ( !(gSystem->AccessPathName(fileName)) ) {
1189 Warning("VersionExists", "The file %s already exists", fileName.Data()) ;
1190 rv = kTRUE ;
fbf811ec 1191 }
1192 }
1193
88cb7938 1194 return rv ;
fbf811ec 1195
1196}
88cb7938 1197
fbf811ec 1198//____________________________________________________________________________
88cb7938 1199UShort_t AliPHOSGetter::EventPattern(void) const
fbf811ec 1200{
88cb7938 1201 // Return the pattern (trigger bit register) of the beam-test event
1202 if(fBTE)
1203 return fBTE->GetPattern() ;
1204 else
1205 return 0 ;
fbf811ec 1206}
1207//____________________________________________________________________________
88cb7938 1208Float_t AliPHOSGetter::BeamEnergy(void) const
0bc3b8ed 1209{
88cb7938 1210 // Return the beam energy of the beam-test event
1211 if(fBTE)
1212 return fBTE->GetBeamEnergy() ;
1213 else
1214 return 0 ;
fbf811ec 1215}
7ca0684e 1216//____________________________________________________________________________
1217
1218AliPHOSCalibData* AliPHOSGetter::CalibData()
1219{
ef868168 1220 // Check if the instance of AliPHOSCalibData exists, and return it
7ca0684e 1221
2bb77d5e 1222 return fgCalibData;
7ca0684e 1223}