]> git.uio.no Git - u/mrichter/AliRoot.git/blame_incremental - MUON/AliMUONData.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
Removing MUON from the Coding Convention Violation top ten
[u/mrichter/AliRoot.git] / MUON / AliMUONData.cxx
... / ...
CommitLineData
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// AliMUONData classes
18// Class containing MUON data: hits, digits, rawclusters, globaltrigger, localtrigger, etc ..
19// The classe makes the lik between the MUON data lists and the event trees from loaders
20// Gines Martinez, Subatech, September 2003
21//
22
23//Root includes
24#include "TNamed.h"
25//AliRoot include
26#include "AliRun.h"
27#include "AliMC.h"
28#include "AliLoader.h"
29#include "AliMUONConstants.h"
30#include "AliMUONData.h"
31#include "AliMUONDigit.h"
32#include "AliMUONHit.h"
33#include "AliMUONLocalTrigger.h"
34#include "AliMUONGlobalTrigger.h"
35#include "AliMUONRawCluster.h"
36#include "AliMUONTrack.h"
37#include "AliMUONTriggerTrack.h"
38ClassImp(AliMUONData)
39
40//_____________________________________________________________________________
41 AliMUONData::AliMUONData():
42 TNamed(),
43 fLoader(0x0),
44 fHits(0x0),
45 fDigits(0x0),
46 fSDigits(0x0),
47 fRawClusters(0x0),
48 fGlobalTrigger(0x0),
49 fLocalTrigger(0x0),
50 fRecTracks(0x0),
51 fRecTriggerTracks(0x0),
52 fNhits(0),
53 fNdigits(0x0),
54 fNSdigits(0x0),
55 fNrawclusters(0x0),
56 fNglobaltrigger(0),
57 fNlocaltrigger(0),
58 fNrectracks(0),
59 fNrectriggertracks(0),
60 fSplitLevel(0)
61{
62 // Default constructor
63}
64//_____________________________________________________________________________
65AliMUONData::AliMUONData(AliLoader * loader, const char* name, const char* title):
66 TNamed(name,title),
67 fLoader(loader),
68 fHits(0x0),
69 fDigits(0x0),
70 fSDigits(0x0),
71 fRawClusters(0x0),
72 fGlobalTrigger(0x0),
73 fLocalTrigger(0x0),
74 fRecTracks(0x0),
75 fRecTriggerTracks(0x0),
76 fNhits(0),
77 fNdigits(0x0),
78 fNSdigits(0x0),
79 fNrawclusters(0x0),
80 fNglobaltrigger(0),
81 fNlocaltrigger(0),
82 fNrectracks(0),
83 fNrectriggertracks(0),
84 fSplitLevel(0)
85{
86 // Constructor for AliMUONData
87
88// fHits = new TClonesArray("AliMUONHit",1000);
89// fNhits = 0;
90// fDigits = new TObjArray(AliMUONConstants::NCh());
91// fNdigits = new Int_t[AliMUONConstants::NCh()];
92// for (Int_t iDetectionPlane=0; iDetectionPlane<AliMUONConstants::NCh() ;iDetectionPlane++) {
93// fDigits->AddAt(new TClonesArray("AliMUONDigit",10000),iDetectionPlane);
94// fNdigits[iDetectionPlane]=0;
95// }
96// fRawClusters = new TObjArray(AliMUONConstants::NTrackingCh());
97// fNrawclusters = new Int_t[AliMUONConstants::NTrackingCh()];
98// for (Int_t iDetectionPlane=0; iDetectionPlane<AliMUONConstants::NTrackingCh();iDetectionPlane++) {
99// fRawClusters->AddAt(new TClonesArray("AliMUONRawCluster",10000),iDetectionPlane);
100// fNrawclusters[iDetectionPlane]=0;
101// }
102// fGlobalTrigger = new TClonesArray("AliMUONGlobalTrigger",1);
103// fNglobaltrigger =0;
104// fLocalTrigger = new TClonesArray("AliMUONLocalTrigger",234);
105// fNlocaltrigger = 0;
106// fRecTracks = new TClonesArray("AliMUONTrack", 100);
107// fNrectracks = 0; // really needed or GetEntriesFast sufficient ????
108
109
110}
111//_____________________________________________________________________________
112AliMUONData::AliMUONData(const AliMUONData& rMUONData):TNamed(rMUONData)
113{
114 // Dummy copy constructor
115 ;
116}
117//_____________________________________________________________________________
118AliMUONData::~AliMUONData()
119{
120 // Destructor for AliMUONData
121 if (fHits) {
122 fHits->Delete();
123 delete fHits;
124 }
125 if (fDigits) {
126 fDigits->Delete();
127 delete fDigits;
128 }
129 if (fSDigits) {
130 fSDigits->Delete();
131 delete fSDigits;
132 }
133 if (fRawClusters) {
134 fRawClusters->Delete();
135 delete fRawClusters;
136 }
137 if (fGlobalTrigger){
138 fGlobalTrigger->Delete();
139 delete fGlobalTrigger;
140 }
141 if (fLocalTrigger){
142 fLocalTrigger->Delete();
143 delete fLocalTrigger;
144 }
145 if (fRecTracks){
146 fRecTracks->Delete();
147 delete fRecTracks;
148 }
149 if (fRecTriggerTracks){
150 fRecTriggerTracks->Delete();
151 delete fRecTriggerTracks;
152 }
153 //detructor
154}
155//_____________________________________________________________________________
156void AliMUONData::AddDigit(Int_t id, Int_t *tracks, Int_t *charges, Int_t *digits)
157{
158 //
159 // Add a MUON digit to the list of Digits of the detection plane id
160 //
161 TClonesArray &ldigits = * Digits(id) ;
162 new(ldigits[fNdigits[id]++]) AliMUONDigit(tracks,charges,digits);
163}
164//_____________________________________________________________________________
165void AliMUONData::AddDigit(Int_t id, const AliMUONDigit& digit)
166{
167 //
168 // Add a MUON digit to the list of Digits of the detection plane id
169 //
170 TClonesArray &ldigits = * Digits(id) ;
171 new(ldigits[fNdigits[id]++]) AliMUONDigit(digit);
172}
173//_____________________________________________________________________________
174void AliMUONData::AddSDigit(Int_t id, Int_t *tracks, Int_t *charges, Int_t *Sdigits)
175{
176 //
177 // Add a MUON Sdigit to the list of SDigits of the detection plane id
178 //
179 TClonesArray &lSdigits = * SDigits(id) ;
180 new(lSdigits[fNSdigits[id]++]) AliMUONDigit(tracks,charges,Sdigits);
181}
182//_____________________________________________________________________________
183void AliMUONData::AddSDigit(Int_t id, const AliMUONDigit& Sdigit)
184{
185 //
186 // Add a MUON Sdigit to the list of SDigits of the detection plane id
187 //
188 TClonesArray &lSdigits = * SDigits(id) ;
189 new(lSdigits[fNSdigits[id]++]) AliMUONDigit(Sdigit);
190}
191//_____________________________________________________________________________
192void AliMUONData::AddGlobalTrigger(Int_t *singlePlus, Int_t *singleMinus,
193 Int_t *singleUndef,
194 Int_t *pairUnlike, Int_t *pairLike)
195{
196 // add a MUON Global Trigger to the list (only one GlobalTrigger per event !)
197 TClonesArray &globalTrigger = *fGlobalTrigger;
198 new(globalTrigger[fNglobaltrigger++])
199 AliMUONGlobalTrigger(singlePlus, singleMinus, singleUndef, pairUnlike, pairLike);
200}
201//_____________________________________________________________________________
202void AliMUONData::AddGlobalTrigger(const AliMUONGlobalTrigger& trigger )
203{
204 // add a MUON Global Trigger to the list (only one GlobalTrigger per event !)
205 TClonesArray &globalTrigger = *fGlobalTrigger;
206 new(globalTrigger[fNglobaltrigger++]) AliMUONGlobalTrigger(trigger);
207}
208//_____________________________________________________________________________
209void AliMUONData::AddHit(Int_t fIshunt, Int_t track, Int_t iChamber,
210 Int_t idpart, Float_t X, Float_t Y, Float_t Z,
211 Float_t tof, Float_t momentum, Float_t theta,
212 Float_t phi, Float_t length, Float_t destep)
213{
214 // Add new hit to the hit list
215 TClonesArray &lhits = *fHits;
216 new(lhits[fNhits++]) AliMUONHit(fIshunt, track, iChamber,
217 idpart, X, Y, Z,
218 tof, momentum, theta,
219 phi, length, destep);
220}
221//____________________________________________________________________________
222void AliMUONData::AddHit(Int_t fIshunt, Int_t track, Int_t iChamber,
223 Int_t idpart, Float_t X, Float_t Y, Float_t Z,
224 Float_t tof, Float_t momentum, Float_t theta,
225 Float_t phi, Float_t length, Float_t destep,
226 Float_t Xref,Float_t Yref,Float_t Zref)
227{
228 // Add new hit to the hit list
229 TClonesArray &lhits = *fHits;
230 new(lhits[fNhits++]) AliMUONHit(fIshunt, track, iChamber,
231 idpart, X, Y, Z,
232 tof, momentum, theta,
233 phi, length, destep,
234 Xref,Yref,Zref);
235}
236//____________________________________________________________________________
237void AliMUONData::AddHit(const AliMUONHit& hit)
238{
239 TClonesArray &lhits = *fHits;
240 new(lhits[fNhits++]) AliMUONHit(hit);
241}
242//____________________________________________________________________________
243void AliMUONData::AddLocalTrigger(Int_t *localtr)
244{
245 // add a MUON Local Trigger to the list
246 TClonesArray &localTrigger = *fLocalTrigger;
247 new(localTrigger[fNlocaltrigger++]) AliMUONLocalTrigger(localtr);
248}
249//____________________________________________________________________________
250void AliMUONData::AddLocalTrigger(const AliMUONLocalTrigger& trigger)
251{
252 // add a MUON Local Trigger to the list
253 TClonesArray &localTrigger = *fLocalTrigger;
254 new(localTrigger[fNlocaltrigger++]) AliMUONLocalTrigger(trigger);
255}
256//_____________________________________________________________________________
257void AliMUONData::AddRawCluster(Int_t id, const AliMUONRawCluster& c)
258{
259 //
260 // Add a MUON rawcluster to the list in the detection plane id
261 //
262 TClonesArray &lrawcl = *((TClonesArray*) fRawClusters->At(id));
263 new(lrawcl[fNrawclusters[id]++]) AliMUONRawCluster(c);
264}
265//_____________________________________________________________________________
266void AliMUONData::AddRecTrack(const AliMUONTrack& track)
267{
268 //
269 // Add a MUON rectrack
270 //
271 TClonesArray &lrectracks = *fRecTracks;
272 new(lrectracks[fNrectracks++]) AliMUONTrack(track);
273 // printf("TTTTTT %d ,\n",((AliMUONTrack*)fRecTracks->At(fNrectracks-1))->GetNTrackHits());
274}
275//_____________________________________________________________________________
276void AliMUONData::AddRecTriggerTrack(const AliMUONTriggerTrack& triggertrack)
277{
278 //
279 // Add a MUON triggerrectrack
280 //
281 TClonesArray &lrectriggertracks = *fRecTriggerTracks;
282 new(lrectriggertracks[fNrectriggertracks++]) AliMUONTriggerTrack(triggertrack);
283 // printf("TTTTTT %d ,\n",((AliMUONTrack*)fRecTracks->At(fNrectracks-1))->GetNTrackHits());
284}
285
286//____________________________________________________________________________
287TClonesArray* AliMUONData::Digits(Int_t DetectionPlane)
288{
289 //Getting List of Digits
290 if (fDigits)
291 return ( (TClonesArray*) fDigits->At(DetectionPlane) );
292 else
293 return NULL;
294}
295//____________________________________________________________________________
296TClonesArray* AliMUONData::SDigits(Int_t DetectionPlane)
297{
298 //Getting List of SDigits
299 if (fSDigits)
300 return ( (TClonesArray*) fSDigits->At(DetectionPlane) );
301 else
302 return NULL;
303}
304//____________________________________________________________________________
305Bool_t AliMUONData::IsRawClusterBranchesInTree()
306{
307 // Checking if there are RawCluster Branches In TreeR
308 if (TreeR()==0x0) {
309 Error("TreeR","No treeR in memory");
310 return kFALSE;
311 }
312 else {
313 char branchname[30];
314 sprintf(branchname,"%sRawClusters1",GetName());
315 TBranch * branch = 0x0;
316 branch = TreeR()->GetBranch(branchname);
317 if (branch) return kTRUE;
318 else return kFALSE;
319 }
320}
321//____________________________________________________________________________
322Bool_t AliMUONData::IsTriggerBranchesInTree()
323{
324 // Checking if there are Trigger Branches In TreeR
325 if (TreeR()==0x0) {
326 Error("TreeR","No treeR in memory");
327 return kFALSE;
328 }
329 else {
330 char branchname[30];
331 sprintf(branchname,"%sLocalTrigger",GetName());
332 TBranch * branch = 0x0;
333 branch = TreeR()->GetBranch(branchname);
334 if (branch) return kTRUE;
335 else return kFALSE;
336 }
337}
338//____________________________________________________________________________
339Bool_t AliMUONData::IsTrackBranchesInTree()
340{
341 // Checking if there are Track Branches In TreeT
342 if (TreeT()==0x0) {
343 Error("TreeT","No treeT in memory");
344 return kFALSE;
345 }
346 else {
347 char branchname[30];
348 sprintf(branchname,"%sTrack",GetName());
349 TBranch * branch = 0x0;
350 branch = TreeT()->GetBranch(branchname);
351 if (branch) return kTRUE;
352 else return kFALSE;
353 }
354}
355//____________________________________________________________________________
356Bool_t AliMUONData::IsTriggerTrackBranchesInTree()
357{
358 // Checking if there are TriggerTrack Branches In TreeT
359 if (TreeT()==0x0) {
360 Error("TreeT","No treeT in memory");
361 return kFALSE;
362 }
363 else {
364 char branchname[30];
365 sprintf(branchname,"%sTriggerTrack",GetName());
366 TBranch * branch = 0x0;
367 branch = TreeT()->GetBranch(branchname);
368 if (branch) return kTRUE;
369 else return kFALSE;
370 }
371}
372//____________________________________________________________________________
373void AliMUONData::Fill(Option_t* option)
374{
375 // Method to fill the trees
376 const char *cH = strstr(option,"H");
377 const char *cD = strstr(option,"D"); // Digits branches in TreeD
378 const char *cS = strstr(option,"S"); // SDigits branches in TreeS
379 const char *cRC = strstr(option,"RC"); // RawCluster branches in TreeR
380 const char *cGLT = strstr(option,"GLT"); // Global and Local Trigger branches in TreeR
381 const char *cRT = strstr(option,"RT"); // Reconstructed Track in TreeT
382 const char *cRL = strstr(option,"RL"); // Reconstructed Trigger Track in TreeT
383
384 //const char *cRP = strstr(option,"RP"); // Reconstructed Particle in TreeP
385
386 char branchname[30];
387 TBranch * branch = 0x0;
388
389 //
390 // Filling TreeH
391 if ( TreeH() && cH ) {
392 TreeH()->Fill();
393 }
394 //
395 // Filling TreeD
396 if ( TreeD() && cD) {
397 TreeD()->Fill();
398 }
399 // Filling TreeS
400 if ( TreeS() && cS) {
401 TreeS()->Fill();
402 }
403
404 //
405 // filling rawclusters
406 if ( TreeR() && cRC ) {
407 if ( IsTriggerBranchesInTree() ) {
408 // Branch per branch filling
409 for (int i=0; i<AliMUONConstants::NTrackingCh(); i++) {
410 sprintf(branchname,"%sRawClusters%d",GetName(),i+1);
411 branch = TreeR()->GetBranch(branchname);
412 branch->Fill();
413 }
414 }
415 else TreeR()->Fill();
416 }
417
418 //
419 // filling trigger
420 if ( TreeR() && cGLT) {
421 if (IsRawClusterBranchesInTree()) {
422 // Branch per branch filling
423 sprintf(branchname,"%sLocalTrigger",GetName());
424 branch = TreeR()->GetBranch(branchname);
425 branch->Fill();
426 sprintf(branchname,"%sGlobalTrigger",GetName());
427 branch = TreeR()->GetBranch(branchname);
428 branch->Fill();
429 }
430 else TreeR()->Fill();
431 }
432 //
433 // filling tracks
434 if ( TreeT() && cRT ) {
435 if (IsTriggerTrackBranchesInTree()) {
436 sprintf(branchname,"%sTrack",GetName());
437 branch = TreeT()->GetBranch(branchname);
438 branch->Fill();
439 }
440 else TreeT()->Fill();
441 }
442 // filling trigger tracks
443 if ( TreeT() && cRL ) {
444 if (IsTrackBranchesInTree()) {
445 sprintf(branchname,"%sTriggerTrack",GetName());
446 branch = TreeT()->GetBranch(branchname);
447 branch->Fill();
448 }
449 else TreeT()->Fill();
450 }
451// if ( TreeT() && cRL ) {
452// sprintf(branchname,"%sTrackTrig",GetName());
453// TreeT()->Fill();
454// }
455}
456//_____________________________________________________________________________
457void AliMUONData::MakeBranch(Option_t* option)
458{
459 //
460 // Create Tree branches for the MUON.
461 //
462 const Int_t kBufferSize = 4000;
463 char branchname[30];
464
465
466 const char *cH = strstr(option,"H");
467 const char *cD = strstr(option,"D"); // Digits branches in TreeD
468 const char *cS = strstr(option,"S"); // Digits branches in TreeS
469 const char *cRC = strstr(option,"RC"); // RawCluster branches in TreeR
470 const char *cGLT = strstr(option,"GLT"); // Global and Local Trigger branches in TreeR
471 const char *cRT = strstr(option,"RT"); // Reconstructed Track in TreeT
472 const char *cRL = strstr(option,"RL"); // Reconstructed Trigger Track in TreeT
473 //const char *cRP = strstr(option,"RP"); // Reconstructed Particle in TreeP
474
475 TBranch * branch = 0x0;
476
477 // Creating Branches for Hits
478 if (TreeH() && cH) {
479
480 if (fHits == 0x0) {
481 fHits = new TClonesArray("AliMUONHit",1000);
482// if (gAlice->GetMCApp())
483// gAlice->GetMCApp()->AddHitList (fHits);
484 }
485
486 fNhits = 0;
487 sprintf(branchname,"%sHits",GetName());
488 branch = TreeH()->GetBranch(branchname);
489 if (branch) {
490 Info("MakeBranch","Branch %s is already in tree.",GetName());
491 return ;
492 }
493 branch = TreeH()->Branch(branchname,&fHits,kBufferSize);
494 //Info("MakeBranch","Making Branch %s for hits \n",branchname);
495 }
496
497 //Creating Branches for Digits
498 if (TreeD() && cD ) {
499 // one branch for digits per chamber
500 if (fDigits == 0x0) {
501 fDigits = new TObjArray(AliMUONConstants::NCh());
502 for (Int_t iDetectionPlane=0; iDetectionPlane<AliMUONConstants::NCh() ;iDetectionPlane++) {
503 TClonesArray * tca = new TClonesArray("AliMUONDigit",10000);
504 tca->SetOwner();
505 fDigits->AddAt(tca,iDetectionPlane);
506 }
507 }
508 if (fNdigits == 0x0) {
509 fNdigits = new Int_t[AliMUONConstants::NCh()];
510 for (Int_t iDetectionPlane=0; iDetectionPlane<AliMUONConstants::NCh() ;iDetectionPlane++) {
511 fNdigits[iDetectionPlane]=0;
512 }
513 }
514 for (Int_t iDetectionPlane=0; iDetectionPlane<AliMUONConstants::NCh() ;iDetectionPlane++) {
515 sprintf(branchname,"%sDigits%d",GetName(),iDetectionPlane+1);
516 branch = 0x0;
517 branch = TreeD()->GetBranch(branchname);
518 if (branch) {
519 Info("MakeBranch","Branch %s is already in tree.",GetName());
520 return;
521 }
522 TClonesArray * digits = Digits(iDetectionPlane);
523 branch = TreeD()->Branch(branchname, &digits, kBufferSize,1);
524 //Info("MakeBranch","Making Branch %s for digits in detection plane %d\n",branchname,iDetectionPlane+1);
525 }
526 }
527
528 //Creating Branches for SDigits
529 if (TreeS() && cS ) {
530 // one branch for Sdigits per chamber
531 if (fSDigits == 0x0) {
532 fSDigits = new TObjArray(AliMUONConstants::NCh());
533 for (Int_t iDetectionPlane=0; iDetectionPlane<AliMUONConstants::NCh() ;iDetectionPlane++) {
534 TClonesArray * tca = new TClonesArray("AliMUONDigit",10000);
535 tca->SetOwner();
536 fSDigits->AddAt(tca,iDetectionPlane);
537 }
538 }
539 if (fNSdigits == 0x0) {
540 fNSdigits = new Int_t[AliMUONConstants::NCh()];
541 for (Int_t iDetectionPlane=0; iDetectionPlane<AliMUONConstants::NCh() ;iDetectionPlane++) {
542 fNSdigits[iDetectionPlane]=0;
543 }
544 }
545 for (Int_t iDetectionPlane=0; iDetectionPlane<AliMUONConstants::NCh() ;iDetectionPlane++) {
546 sprintf(branchname,"%sSDigits%d",GetName(),iDetectionPlane+1);
547 branch = 0x0;
548 branch = TreeS()->GetBranch(branchname);
549 if (branch) {
550 Info("MakeBranch","Branch %s is already in tree.",GetName());
551 return;
552 }
553 TClonesArray * Sdigits = SDigits(iDetectionPlane);
554 branch = TreeS()->Branch(branchname, &Sdigits, kBufferSize,1);
555 //Info("MakeBranch","Making Branch %s for Sdigits in detection plane %d\n",branchname,iDetectionPlane+1);
556 }
557 }
558
559 if (TreeR() && cRC ) {
560 // one branch for raw clusters per tracking detection plane
561 //
562 Int_t i;
563 if (fRawClusters == 0x0) {
564 fRawClusters = new TObjArray(AliMUONConstants::NTrackingCh());
565 for (Int_t i=0; i<AliMUONConstants::NTrackingCh();i++) {
566 TClonesArray * tca = new TClonesArray("AliMUONRawCluster",1000);
567 tca->SetOwner();
568 fRawClusters->AddAt(tca,i);
569 }
570 }
571
572 if (fNrawclusters == 0x0) {
573 fNrawclusters= new Int_t[AliMUONConstants::NTrackingCh()];
574 for (Int_t i=0; i<AliMUONConstants::NTrackingCh();i++) {
575 fNrawclusters[i]=0;
576 }
577 }
578
579 for (i=0; i<AliMUONConstants::NTrackingCh() ;i++) {
580 sprintf(branchname,"%sRawClusters%d",GetName(),i+1);
581 branch = 0x0;
582 branch = TreeR()->GetBranch(branchname);
583 if (branch) {
584 Info("MakeBranch","Branch %s is already in tree.",GetName());
585 return;
586 }
587 branch = TreeR()->Branch(branchname, &((*fRawClusters)[i]),kBufferSize);
588 //Info("MakeBranch","Making Branch %s for rawcluster in detection plane %d\n",branchname,i+1);
589 }
590 }
591
592 if (TreeR() && cGLT ) {
593 //
594 // one branch for global trigger
595 //
596 sprintf(branchname,"%sGlobalTrigger",GetName());
597 branch = 0x0;
598
599 if (fGlobalTrigger == 0x0) {
600 fGlobalTrigger = new TClonesArray("AliMUONGlobalTrigger");
601 fNglobaltrigger = 0;
602 }
603 branch = TreeR()->GetBranch(branchname);
604 if (branch) {
605 Info("MakeBranch","Branch %s is already in tree.",GetName());
606 return ;
607 }
608 branch = TreeR()->Branch(branchname, &fGlobalTrigger, kBufferSize);
609 //Info("MakeBranch", "Making Branch %s for Global Trigger\n",branchname);
610
611 //
612 // one branch for local trigger
613 //
614 sprintf(branchname,"%sLocalTrigger",GetName());
615 branch = 0x0;
616
617 if (fLocalTrigger == 0x0) {
618 fLocalTrigger = new TClonesArray("AliMUONLocalTrigger",234);
619 fNlocaltrigger = 0;
620 }
621 branch = TreeR()->GetBranch(branchname);
622 if (branch) {
623 Info("MakeBranch","Branch %s is already in tree.",GetName());
624 return;
625 }
626 branch = TreeR()->Branch(branchname, &fLocalTrigger, kBufferSize);
627 //Info("MakeBranch", "Making Branch %s for Global Trigger\n",branchname);
628 }
629
630 if (TreeT() && cRT ) {
631 if (fRecTracks == 0x0) fRecTracks = new TClonesArray("AliMUONTrack",100);
632 fNrectracks = 0;
633 sprintf(branchname,"%sTrack",GetName());
634 branch = TreeT()->GetBranch(branchname);
635 if (branch) {
636 Info("MakeBranch","Branch %s is already in tree.",GetName());
637 return ;
638 }
639 branch = TreeT()->Branch(branchname,&fRecTracks,kBufferSize);
640 //Info("MakeBranch","Making Branch %s for tracks \n",branchname);
641 }
642// trigger tracks
643 if (TreeT() && cRL ) {
644 if (fRecTriggerTracks == 0x0) fRecTriggerTracks = new TClonesArray("AliMUONTriggerTrack",100);
645 fNrectriggertracks = 0;
646 sprintf(branchname,"%sTriggerTrack",GetName());
647 branch = TreeT()->GetBranch(branchname);
648 if (branch) {
649 Info("MakeBranch","Branch %s is already in tree.",GetName());
650 return ;
651 }
652 branch = TreeT()->Branch(branchname,&fRecTriggerTracks,kBufferSize);
653 //Info("MakeBranch","Making Branch %s for trigger tracks \n",branchname);
654 }
655}
656//____________________________________________________________________________
657TClonesArray* AliMUONData::RawClusters(Int_t DetectionPlane)
658{
659 // Getting Raw Clusters
660 if (fRawClusters)
661 return ( (TClonesArray*) fRawClusters->At(DetectionPlane) );
662 else
663 return NULL;
664}
665//____________________________________________________________________________
666TClonesArray* AliMUONData::LocalTrigger()
667{
668 // Getting Local Trigger
669 if (fLocalTrigger)
670 return ( (TClonesArray*) fLocalTrigger );
671 else
672 return NULL;
673}
674//____________________________________________________________________________
675TClonesArray* AliMUONData::GlobalTrigger()
676{
677 // Getting Global Trigger
678 if (fGlobalTrigger)
679 return ( (TClonesArray*) fGlobalTrigger );
680 else
681 return NULL;
682}
683//____________________________________________________________________________
684void AliMUONData::ResetDigits()
685{
686 //
687 // Reset number of digits and the digits array for this detector
688 //
689 if (fDigits == 0x0) return;
690 for ( int i=0;i<AliMUONConstants::NCh();i++ ) {
691 if ((*fDigits)[i]) ((TClonesArray*)fDigits->At(i))->Clear();
692 if (fNdigits) fNdigits[i]=0;
693 }
694}
695//____________________________________________________________________________
696void AliMUONData::ResetSDigits()
697{
698 //
699 // Reset number of Sdigits and the Sdigits array for this detector
700 //
701 if (fSDigits == 0x0) return;
702 for ( int i=0;i<AliMUONConstants::NCh();i++ ) {
703 if ((*fSDigits)[i]) ((TClonesArray*)fSDigits->At(i))->Clear();
704 if (fNSdigits) fNSdigits[i]=0;
705 }
706}
707//______________________________________________________________________________
708void AliMUONData::ResetHits()
709{
710 // Reset number of clusters and the cluster array for this detector
711 fNhits = 0;
712 if (fHits) fHits->Clear();
713}
714//_______________________________________________________________________________
715void AliMUONData::ResetRawClusters()
716{
717 // Reset number of raw clusters and the raw clust array for this detector
718 //
719 for ( int i=0;i<AliMUONConstants::NTrackingCh();i++ ) {
720 if ((*fRawClusters)[i]) ((TClonesArray*)fRawClusters->At(i))->Clear();
721 if (fNrawclusters) fNrawclusters[i]=0;
722 }
723}
724//_______________________________________________________________________________
725void AliMUONData::ResetTrigger()
726{
727 // Reset Local and Global Trigger
728 fNglobaltrigger = 0;
729 if (fGlobalTrigger) fGlobalTrigger->Clear();
730 fNlocaltrigger = 0;
731 if (fLocalTrigger) fLocalTrigger->Clear();
732}
733//____________________________________________________________________________
734void AliMUONData::ResetRecTracks()
735{
736 // Reset tracks information
737 fNrectracks = 0;
738 if (fRecTracks) fRecTracks->Clear();
739}
740//____________________________________________________________________________
741void AliMUONData::ResetRecTriggerTracks()
742{
743 // Reset tracks information
744 fNrectriggertracks = 0;
745 if (fRecTriggerTracks) fRecTriggerTracks->Clear();
746}
747//_____________________________________________________________________________
748void AliMUONData::SetTreeAddress(Option_t* option)
749{
750 //Setting Addresses to the events trees
751 const char *cH = strstr(option,"H");
752 const char *cD = strstr(option,"D"); // Digits branches in TreeD
753 const char *cS = strstr(option,"S"); // SDigits branches in TreeS
754 const char *cRC = strstr(option,"RC"); // RawCluster branches in TreeR
755 const char *cGLT = strstr(option,"GLT"); // Global and Local Trigger branches in TreeR
756 const char *cRT = strstr(option,"RT"); // Reconstructed Track in TreeT
757 const char *cRL = strstr(option,"RL"); // Reconstructed Trigger Track in TreeT
758 //const char *cRP = strstr(option,"RP"); // Reconstructed Particle in TreeP
759
760 // Set branch address for the Hits, Digits, RawClusters, GlobalTrigger and LocalTrigger Tree.
761 char branchname[30];
762 TBranch * branch = 0x0;
763
764 //
765 // Branch address for hit tree
766 if ( TreeH() && cH ) {
767 if (fHits == 0x0) {
768 fHits = new TClonesArray("AliMUONHit",1000);
769 // if (gAlice->GetMCApp())
770 // gAlice->GetMCApp()->AddHitList (fHits); Moved to AliMUON
771 }
772 fNhits =0;
773 }
774 if (TreeH() && fHits && cH) {
775 sprintf(branchname,"%sHits",GetName());
776 branch = TreeH()->GetBranch(branchname);
777 if (branch) {
778 // Info("SetTreeAddress","(%s) Setting for Hits",GetName());
779 branch->SetAddress(&fHits);
780 }
781 else { //can be invoked before branch creation
782 Warning("SetTreeAddress","(%s) Failed for Hits. Can not find branch in tree.",GetName());
783 }
784 }
785
786 //
787 // Branch address for digit tree
788 if ( TreeD() && cD) {
789 if (fDigits == 0x0) {
790 fDigits = new TObjArray(AliMUONConstants::NCh());
791 fNdigits= new Int_t[AliMUONConstants::NCh()];
792 for (Int_t i=0; i<AliMUONConstants::NCh() ;i++) {
793 fDigits->AddAt(new TClonesArray("AliMUONDigit",10000),i);
794 fNdigits[i]=0;
795 }
796 }
797 }
798
799 if (TreeD() && fDigits && cD) {
800 for (int i=0; i<AliMUONConstants::NCh(); i++) {
801 sprintf(branchname,"%sDigits%d",GetName(),i+1);
802 if (fDigits) {
803 branch = TreeD()->GetBranch(branchname);
804 TClonesArray * digits = Digits(i);
805 if (branch) {
806 branch->SetAddress( &digits );
807 }
808 else Warning("SetTreeAddress","(%s) Failed for Digits Detection plane %d. Can not find branch in tree.",GetName(),i);
809 }
810 }
811 }
812 //
813 // Branch address for Sdigit tree
814 if ( TreeS() && cS) {
815 if (fSDigits == 0x0) {
816 fSDigits = new TObjArray(AliMUONConstants::NCh());
817 fNSdigits= new Int_t[AliMUONConstants::NCh()];
818 for (Int_t i=0; i<AliMUONConstants::NCh() ;i++) {
819 fSDigits->AddAt(new TClonesArray("AliMUONDigit",10000),i);
820 fNSdigits[i]=0;
821 }
822 }
823 }
824
825 if (TreeS() && fSDigits && cS) {
826 for (int i=0; i<AliMUONConstants::NCh(); i++) {
827 sprintf(branchname,"%sSDigits%d",GetName(),i+1);
828 if (fSDigits) {
829 branch = TreeS()->GetBranch(branchname);
830 TClonesArray * Sdigits = SDigits(i);
831 if (branch) branch->SetAddress( &Sdigits );
832 else Warning("SetTreeAddress","(%s) Failed for SDigits Detection plane %d. Can not find branch in tree.",GetName(),i);
833 }
834 }
835 }
836
837 //
838 // Branch address for rawclusters, globaltrigger and local trigger tree
839 if (TreeR() ) {
840 if (fRawClusters == 0x0 && cRC) {
841 fRawClusters = new TObjArray(AliMUONConstants::NTrackingCh());
842 fNrawclusters= new Int_t[AliMUONConstants::NTrackingCh()];
843 for (Int_t i=0; i<AliMUONConstants::NTrackingCh();i++) {
844 fRawClusters->AddAt(new TClonesArray("AliMUONRawCluster",10000),i);
845 fNrawclusters[i]=0;
846 }
847 }
848 if (fLocalTrigger == 0x0 && cGLT) {
849 fLocalTrigger = new TClonesArray("AliMUONLocalTrigger",234);
850 }
851 if (fGlobalTrigger== 0x0 && cGLT) {
852 fGlobalTrigger = new TClonesArray("AliMUONGlobalTrigger",1);
853 }
854
855 }
856 if ( TreeR() && fRawClusters && cRC) {
857 for (int i=0; i<AliMUONConstants::NTrackingCh(); i++) {
858 sprintf(branchname,"%sRawClusters%d",GetName(),i+1);
859 if (fRawClusters) {
860 branch = TreeR()->GetBranch(branchname);
861 if (branch) branch->SetAddress( &((*fRawClusters)[i]) );
862 else Warning("SetTreeAddress","(%s) Failed for RawClusters Detection plane %d. Can not find branch in tree.",GetName(),i);
863 }
864 }
865 }
866 if ( TreeR() && fLocalTrigger && cGLT) {
867 sprintf(branchname,"%sLocalTrigger",GetName());
868 branch = TreeR()->GetBranch(branchname);
869 if (branch) branch->SetAddress(&fLocalTrigger);
870 else Warning("SetTreeAddress","(%s) Failed for LocalTrigger. Can not find branch in tree.",GetName());
871 }
872 if ( TreeR() && fGlobalTrigger && cGLT) {
873 sprintf(branchname,"%sGlobalTrigger",GetName());
874 branch = TreeR()->GetBranch(branchname);
875 if (branch) branch->SetAddress(&fGlobalTrigger);
876 else Warning("SetTreeAddress","(%s) Failed for LocalTrigger. Can not find branch in tree.",GetName());
877 }
878
879 if ( TreeT() ) {
880 if (fRecTracks == 0x0 && cRT) {
881 fRecTracks = new TClonesArray("AliMUONTrack",100);
882 }
883
884 }
885 if ( TreeT() && fRecTracks && cRT ) {
886 sprintf(branchname,"%sTrack",GetName());
887 branch = TreeT()->GetBranch(branchname);
888 if (branch) branch->SetAddress(&fRecTracks);
889 else Warning("SetTreeAddress","(%s) Failed for Tracks. Can not find branch in tree.",GetName());
890 }
891// trigger tracks
892 if ( TreeT() ) {
893 if (fRecTriggerTracks == 0x0 && cRL) {
894 fRecTriggerTracks = new TClonesArray("AliMUONTriggerTrack",100);
895 }
896
897 }
898 if ( TreeT() && fRecTriggerTracks && cRL ) {
899 sprintf(branchname,"%sTriggerTrack",GetName());
900 branch = TreeT()->GetBranch(branchname);
901 if (branch) branch->SetAddress(&fRecTriggerTracks);
902 else Warning("SetTreeAddress","(%s) Failed for Trigger Tracks. Can not find branch in tree.",GetName());
903 }
904
905
906}
907//_____________________________________________________________________________