]> git.uio.no Git - u/mrichter/AliRoot.git/blame_incremental - MUON/AliMUON.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
Sample program for using the simple fast cluster finder.
[u/mrichter/AliRoot.git] / MUON / AliMUON.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$Log$
17Revision 1.55 2001/09/07 08:38:30 hristov
18Pointers initialised to 0 in the default constructors
19
20Revision 1.54 2001/08/30 09:52:12 hristov
21The operator[] is replaced by At() or AddAt() in case of TObjArray.
22
23Revision 1.53 2001/07/20 10:03:13 morsch
24Changes needed to work with Root 3.01 (substitute lhs [] operator). (Jiri Chudoba)
25
26Revision 1.52 2001/06/14 13:49:22 hristov
27Write a TreeD in SDigits2Digits method (needed to be compatible with alirun script)
28
29Revision 1.51 2001/05/31 10:19:52 morsch
30Fix for new AliRun::RunReco().
31
32Revision 1.50 2001/05/16 14:57:17 alibrary
33New files for folders and Stack
34
35Revision 1.49 2001/03/12 17:45:48 hristov
36Changes needed on Sun with CC 5.0
37
38Revision 1.48 2001/03/06 00:01:36 morsch
39Add Digits2Reco() and FindClusters()
40Adapt call of cluster finder to new STEER.
41
42Revision 1.47 2001/03/05 08:38:36 morsch
43Digitization related methods moved to AliMUONMerger.
44
45Revision 1.46 2001/01/26 21:34:59 morsch
46Use access functions for AliMUONHit, AliMUONDigit and AliMUONPadHit data members.
47
48Revision 1.45 2001/01/26 20:00:49 hristov
49Major upgrade of AliRoot code
50
51Revision 1.44 2001/01/25 17:39:09 morsch
52Pass size of fNdch and fNrawch to CINT.
53
54Revision 1.43 2001/01/23 18:58:19 hristov
55Initialisation of some pointers
56
57Revision 1.42 2001/01/17 20:53:40 hristov
58Destructors corrected to avoid memory leaks
59
60Revision 1.41 2000/12/21 22:12:40 morsch
61Clean-up of coding rule violations,
62
63Revision 1.40 2000/11/29 20:32:26 gosset
64Digitize:
651. correction for array index out of bounds
662. one printout commented
67
68Revision 1.39 2000/11/12 17:17:03 pcrochet
69BuildGeometry of AliMUON for trigger chambers delegated to AliMUONSegmentationTriggerX (same strategy as for tracking chambers)
70
71Revision 1.38 2000/11/06 09:20:43 morsch
72AliMUON delegates part of BuildGeometry() to AliMUONSegmentation using the
73Draw() method. This avoids code and parameter replication.
74
75Revision 1.37 2000/10/26 09:53:37 pcrochet
76put back trigger chambers in the display (there was a problem in buildgeometry)
77
78Revision 1.36 2000/10/25 19:51:18 morsch
79Correct x-position of chambers.
80
81Revision 1.35 2000/10/24 19:46:21 morsch
82BuildGeometry updated for slats in station 3-4.
83
84Revision 1.34 2000/10/18 11:42:06 morsch
85- AliMUONRawCluster contains z-position.
86- Some clean-up of useless print statements during initialisations.
87
88Revision 1.33 2000/10/09 14:01:57 morsch
89Unused variables removed.
90
91Revision 1.32 2000/10/06 09:08:10 morsch
92Built geometry includes slat geometry for event display.
93
94Revision 1.31 2000/10/02 21:28:08 fca
95Removal of useless dependecies via forward declarations
96
97Revision 1.30 2000/10/02 16:58:29 egangler
98Cleaning of the code :
99-> coding conventions
100-> void Streamers
101-> some useless includes removed or replaced by "class" statement
102
103Revision 1.29 2000/07/28 13:49:38 morsch
104SetAcceptance defines inner and outer chamber radii according to angular acceptance.
105Can be used for simple acceptance studies.
106
107Revision 1.28 2000/07/22 16:43:15 morsch
108Same comment as before, but now done correctly I hope (sorry it's Saturday evening)
109
110Revision 1.27 2000/07/22 16:36:50 morsch
111Change order of indices in creation (new) of xhit and yhit
112
113Revision 1.26 2000/07/03 11:54:57 morsch
114AliMUONSegmentation and AliMUONHitMap have been replaced by AliSegmentation and AliHitMap in STEER
115The methods GetPadIxy and GetPadXxy of AliMUONSegmentation have changed name to GetPadI and GetPadC.
116
117Revision 1.25 2000/06/29 12:34:09 morsch
118AliMUONSegmentation class has been made independent of AliMUONChamber. This makes
119it usable with any other geometry class. The link to the object to which it belongs is
120established via an index. This assumes that there exists a global geometry manager
121from which the pointer to the parent object can be obtained (in our case gAlice).
122
123Revision 1.24 2000/06/28 15:16:35 morsch
124(1) Client code adapted to new method signatures in AliMUONSegmentation (see comments there)
125to allow development of slat-muon chamber simulation and reconstruction code in the MUON
126framework. The changes should have no side effects (mostly dummy arguments).
127(2) Hit disintegration uses 3-dim hit coordinates to allow simulation
128of chambers with overlapping modules (MakePadHits, Disintegration).
129
130Revision 1.23 2000/06/28 12:19:17 morsch
131More consequent seperation of global input data services (AliMUONClusterInput singleton) and the
132cluster and hit reconstruction algorithms in AliMUONClusterFindRawinderVS.
133AliMUONClusterFinderVS becomes the base class for clustering and hit reconstruction.
134It requires two cathode planes. Small modifications in the code will make it usable for
135one cathode plane and, hence, more general (for test beam data).
136AliMUONClusterFinder is now obsolete.
137
138Revision 1.22 2000/06/28 08:06:10 morsch
139Avoid global variables in AliMUONClusterFinderVS by seperating the input data for the fit from the
140algorithmic part of the class. Input data resides inside the AliMUONClusterInput singleton.
141It also naturally takes care of the TMinuit instance.
142
143Revision 1.21 2000/06/27 08:54:41 morsch
144Problems with on constant array sizes (in hitMap, nmuon, xhit, yhit) corrected.
145
146Revision 1.20 2000/06/26 14:02:38 morsch
147Add class AliMUONConstants with MUON specific constants using static memeber data and access methods.
148
149Revision 1.19 2000/06/22 13:40:51 morsch
150scope problem on HP, "i" declared once
151pow changed to TMath::Power (PH, AM)
152
153Revision 1.18 2000/06/15 07:58:48 morsch
154Code from MUON-dev joined
155
156Revision 1.14.4.17 2000/06/14 14:36:46 morsch
157- add TriggerCircuit (PC)
158- add GlobalTrigger and LocalTrigger and specific methods (PC)
159
160Revision 1.14.4.16 2000/06/09 21:20:28 morsch
161Most coding rule violations corrected
162
163Revision 1.14.4.15 2000/05/02 09:54:32 morsch
164RULE RN17 violations corrected
165
166Revision 1.14.4.12 2000/04/26 12:25:02 morsch
167Code revised by P. Crochet:
168- Z position of TriggerChamber changed according to A.Tournaire Priv.Comm.
169- ToF included in the method MakePadHits
170- inner radius of flange between beam shielding and trigger corrected
171- Trigger global volume updated (according to the new geometry)
172
173Revision 1.14.4.11 2000/04/19 19:42:08 morsch
174Some changes of variable names curing viols and methods concerning
175correlated clusters removed.
176
177Revision 1.14.4.10 2000/03/22 16:44:07 gosset
178Memory leak suppressed in function Digitise:
179p_adr->Delete() instead of Clear (I.Chevrot and A.Baldisseri)
180
181Revision 1.14.4.9 2000/03/20 18:15:25 morsch
182Positions of trigger chambers corrected (P.C.)
183
184Revision 1.14.4.8 2000/02/21 15:38:01 morsch
185Call to AddHitList introduced to make this version compatible with head.
186
187Revision 1.14.4.7 2000/02/20 07:45:53 morsch
188Bugs in Trigger part of BuildGeomemetry corrected (P.C)
189
190Revision 1.14.4.6 2000/02/17 14:28:54 morsch
191Trigger included into initialization and digitization
192
193Revision 1.14.4.5 2000/02/15 10:02:58 morsch
194Log messages of previous revisions added
195
196Revision 1.14.4.2 2000/02/04 10:57:34 gosset
197Z position of the chambers:
198it was the Z position of the stations;
199it is now really the Z position of the chambers.
200 !!!! WARNING: THE CALLS TO "AliMUONChamber::SetZPOS"
201 !!!! AND "AliMUONChamber::ZPosition"
202 !!!! HAVE TO BE CHANGED TO "AliMUONChamber::"SetZ"
203 !!!! AND "AliMUONChamber::Z"
204
205Revision 1.14.4.3 2000/02/04 16:19:04 gosset
206Correction for mis-spelling of NCH
207
208Revision 1.14.4.4 2000/02/15 09:43:38 morsch
209Log message added
210
211*/
212
213
214///////////////////////////////////////////////
215// Manager and hits classes for set:MUON //
216////////////////////////////////////////////////
217
218#include <TTUBE.h>
219#include <TBRIK.h>
220#include <TRotMatrix.h>
221#include <TGeometry.h>
222#include <TNode.h>
223#include <TTree.h>
224#include <TRandom.h>
225#include <TObject.h>
226#include <TVector.h>
227#include <TObjArray.h>
228#include <TMinuit.h>
229#include <TParticle.h>
230#include <TROOT.h>
231#include <TFile.h>
232#include <TNtuple.h>
233#include <TCanvas.h>
234#include <TPad.h>
235#include <TDirectory.h>
236#include <TObjectTable.h>
237#include <AliPDG.h>
238#include <TTUBE.h>
239
240#include "AliMUON.h"
241#include "AliMUONHit.h"
242#include "AliMUONPadHit.h"
243#include "AliMUONDigit.h"
244#include "AliMUONTransientDigit.h"
245#include "AliMUONRawCluster.h"
246#include "AliMUONLocalTrigger.h"
247#include "AliMUONGlobalTrigger.h"
248#include "AliMUONTriggerCircuit.h"
249#include "AliHitMap.h"
250#include "AliMUONHitMapA1.h"
251#include "AliMUONChamberTrigger.h"
252#include "AliMUONConstants.h"
253#include "AliMUONClusterFinderVS.h"
254#include "AliMUONTriggerDecision.h"
255#include "AliRun.h"
256#include "AliHeader.h"
257#include "AliMC.h"
258#include "AliMUONClusterInput.h"
259#include "AliMUONMerger.h"
260#include "iostream.h"
261#include "AliCallf77.h"
262#include "AliConst.h"
263
264// Defaults parameters for Z positions of chambers
265// taken from values for "stations" in AliMUON::AliMUON
266// const Float_t zch[7]={528, 690., 975., 1249., 1449., 1610, 1710.};
267// and from array "dstation" in AliMUONv1::CreateGeometry
268// Float_t dstation[5]={20., 20., 20, 20., 20.};
269// for tracking chambers,
270// according to (Z1 = zch - dstation) and (Z2 = zch + dstation)
271// for the first and second chambers in the station, respectively,
272// and from "DTPLANES" in AliMUONv1::CreateGeometry
273// const Float_t DTPLANES = 15.;
274// for trigger chambers,
275// according to (Z1 = zch) and (Z2 = zch + DTPLANES)
276// for the first and second chambers in the station, respectively
277
278ClassImp(AliMUON)
279//___________________________________________
280AliMUON::AliMUON()
281{
282// Default Constructor
283//
284 fNCh = 0;
285 fNTrackingCh = 0;
286 fIshunt = 0;
287 fPadHits = 0;
288 fNPadHits = 0;
289 fChambers = 0;
290 fDchambers = 0;
291 fTriggerCircuits = 0;
292 fNdch = 0;
293 fRawClusters = 0;
294 fNrawch = 0;
295 fGlobalTrigger = 0;
296 fNLocalTrigger = 0;
297 fLocalTrigger = 0;
298 fNLocalTrigger = 0;
299 fAccMin = 0.;
300 fAccMax = 0.;
301 fAccCut = kFALSE;
302 fMerger = 0;
303 fFileName = 0;
304}
305
306//___________________________________________
307AliMUON::AliMUON(const char *name, const char *title)
308 : AliDetector(name,title)
309{
310//Begin_Html
311/*
312<img src="gif/alimuon.gif">
313*/
314//End_Html
315
316 fHits = new TClonesArray("AliMUONHit",1000);
317 gAlice->AddHitList(fHits);
318 fPadHits = new TClonesArray("AliMUONPadHit",10000);
319 fNPadHits = 0;
320 fIshunt = 0;
321
322 fNCh = AliMUONConstants::NCh();
323 fNTrackingCh = AliMUONConstants::NTrackingCh();
324 fNdch = new Int_t[fNCh];
325
326 fDchambers = new TObjArray(AliMUONConstants::NCh());
327
328 Int_t i;
329
330 for (i=0; i<AliMUONConstants::NCh() ;i++) {
331 fDchambers->AddAt(new TClonesArray("AliMUONDigit",10000),i);
332 fNdch[i]=0;
333 }
334
335 fNrawch = new Int_t[fNTrackingCh];
336
337 fRawClusters = new TObjArray(AliMUONConstants::NTrackingCh());
338
339 for (i=0; i<AliMUONConstants::NTrackingCh();i++) {
340 fRawClusters->AddAt(new TClonesArray("AliMUONRawCluster",10000),i);
341 fNrawch[i]=0;
342 }
343
344 fGlobalTrigger = new TClonesArray("AliMUONGlobalTrigger",1);
345 fNGlobalTrigger = 0;
346 fLocalTrigger = new TClonesArray("AliMUONLocalTrigger",234);
347 fNLocalTrigger = 0;
348
349 SetMarkerColor(kRed);
350//
351//
352//
353//
354
355 Int_t ch;
356
357 fChambers = new TObjArray(AliMUONConstants::NCh());
358
359 // Loop over stations
360 for (Int_t st = 0; st < AliMUONConstants::NCh() / 2; st++) {
361 // Loop over 2 chambers in the station
362 for (Int_t stCH = 0; stCH < 2; stCH++) {
363//
364//
365// Default Parameters for Muon Tracking Stations
366
367
368 ch = 2 * st + stCH;
369//
370 if (ch < AliMUONConstants::NTrackingCh()) {
371 fChambers->AddAt(new AliMUONChamber(ch),ch);
372 } else {
373 fChambers->AddAt(new AliMUONChamberTrigger(ch),ch);
374 }
375
376 //PH AliMUONChamber* chamber = (AliMUONChamber*) (*fChambers)[ch];
377 AliMUONChamber* chamber = (AliMUONChamber*) fChambers->At(ch);
378
379 chamber->SetGid(0);
380 // Default values for Z of chambers
381 chamber->SetZ(AliMUONConstants::DefaultChamberZ(ch));
382//
383 chamber->InitGeo(AliMUONConstants::DefaultChamberZ(ch));
384// Set chamber inner and outer radius to default
385 chamber->SetRInner(AliMUONConstants::Dmin(st)/2);
386 chamber->SetROuter(AliMUONConstants::Dmax(st)/2);
387//
388 } // Chamber stCH (0, 1) in
389 } // Station st (0...)
390// fChambers->SetLast(AliMUONConstants::NCh());
391 fMaxStepGas=0.01;
392 fMaxStepAlu=0.1;
393 fMaxDestepGas=-1;
394 fMaxDestepAlu=-1;
395//
396 fMaxIterPad = 0;
397 fCurIterPad = 0;
398//
399 fAccMin = 0.;
400 fAccMax = 0.;
401 fAccCut = kFALSE;
402
403 // cp new design of AliMUONTriggerDecision
404 fTriggerCircuits = new TObjArray(AliMUONConstants::NTriggerCircuit());
405 for (Int_t circ=0; circ<AliMUONConstants::NTriggerCircuit(); circ++) {
406 fTriggerCircuits->AddAt(new AliMUONTriggerCircuit(),circ);
407
408 }
409 fMerger = 0;
410}
411
412//___________________________________________
413AliMUON::AliMUON(const AliMUON& rMUON)
414{
415// Dummy copy constructor
416 ;
417
418}
419
420AliMUON::~AliMUON()
421{
422// Destructor
423 if(fDebug) printf("%s: Calling AliMUON destructor !!!\n",ClassName());
424
425 Int_t i;
426 fIshunt = 0;
427
428 // Delete TObjArrays
429
430 if (fChambers){
431 fChambers->Delete();
432 delete fChambers;
433 }
434
435 if (fTriggerCircuits){
436 fTriggerCircuits->Delete();
437 delete fTriggerCircuits;
438 }
439
440 if (fDchambers){
441 fDchambers->Delete();
442 delete fDchambers;
443 }
444
445 if (fRawClusters){
446 fRawClusters->Delete();
447 delete fRawClusters;
448 }
449
450 if (fNrawch) delete [] fNrawch;
451
452 // Delete TClonesArrays
453
454 if (fPadHits){
455 fPadHits->Delete();
456 delete fPadHits;
457 }
458
459 if (fGlobalTrigger){
460 fGlobalTrigger->Delete();
461 delete fGlobalTrigger;
462 }
463 fNGlobalTrigger = 0;
464
465 if (fLocalTrigger){
466 fLocalTrigger->Delete();
467 delete fLocalTrigger;
468 }
469 fNLocalTrigger = 0;
470
471 if (fHits) {
472 fHits->Delete();
473 delete fHits;
474 }
475
476 if (fMerger) delete fMerger;
477 if (fNdch) delete [] fNdch;
478
479}
480
481//___________________________________________
482void AliMUON::AddHit(Int_t track, Int_t *vol, Float_t *hits)
483{
484 TClonesArray &lhits = *fHits;
485 new(lhits[fNhits++]) AliMUONHit(fIshunt,track,vol,hits);
486}
487//___________________________________________
488void AliMUON::AddPadHit(Int_t *clhits)
489{
490 TClonesArray &lclusters = *fPadHits;
491 new(lclusters[fNPadHits++]) AliMUONPadHit(clhits);
492}
493//_____________________________________________________________________________
494void AliMUON::AddDigits(Int_t id, Int_t *tracks, Int_t *charges, Int_t *digits)
495{
496 //
497 // Add a MUON digit to the list
498 //
499
500 //PH TClonesArray &ldigits = *((TClonesArray*)(*fDchambers)[id]);
501 TClonesArray &ldigits = *((TClonesArray*)fDchambers->At(id));
502 new(ldigits[fNdch[id]++]) AliMUONDigit(tracks,charges,digits);
503}
504
505//_____________________________________________________________________________
506void AliMUON::AddRawCluster(Int_t id, const AliMUONRawCluster& c)
507{
508 //
509 // Add a MUON digit to the list
510 //
511
512 //PH TClonesArray &lrawcl = *((TClonesArray*)(*fRawClusters)[id]);
513 TClonesArray &lrawcl = *((TClonesArray*)fRawClusters->At(id));
514 new(lrawcl[fNrawch[id]++]) AliMUONRawCluster(c);
515}
516
517//___________________________________________
518void AliMUON::AddGlobalTrigger(Int_t *singlePlus, Int_t *singleMinus,
519 Int_t *singleUndef,
520 Int_t *pairUnlike, Int_t *pairLike)
521{
522// add a MUON Global Trigger to the list (only one GlobalTrigger per event !)
523 TClonesArray &globalTrigger = *fGlobalTrigger;
524 new(globalTrigger[fNGlobalTrigger++])
525 AliMUONGlobalTrigger(singlePlus, singleMinus, singleUndef, pairUnlike,
526 pairLike);
527}
528//___________________________________________
529void AliMUON::AddLocalTrigger(Int_t *localtr)
530{
531// add a MUON Local Trigger to the list
532 TClonesArray &localTrigger = *fLocalTrigger;
533 new(localTrigger[fNLocalTrigger++]) AliMUONLocalTrigger(localtr);
534}
535
536//___________________________________________
537void AliMUON::BuildGeometry()
538{
539// Geometry for event display
540 for (Int_t i=0; i<7; i++) {
541 for (Int_t j=0; j<2; j++) {
542 Int_t id=2*i+j+1;
543 this->Chamber(id-1).SegmentationModel(1)->Draw("eventdisplay");
544 }
545 }
546}
547
548//___________________________________________
549Int_t AliMUON::DistancetoPrimitive(Int_t , Int_t )
550{
551 return 9999;
552}
553
554//___________________________________________
555void AliMUON::MakeBranch(Option_t* option, const char *file)
556{
557 //
558 // Create Tree branches for the MUON.
559 //
560 const Int_t kBufferSize = 4000;
561 char branchname[30];
562 sprintf(branchname,"%sCluster",GetName());
563
564 AliDetector::MakeBranch(option,file);
565
566 const char *cD = strstr(option,"D");
567 const char *cR = strstr(option,"R");
568 const char *cH = strstr(option,"H");
569
570 if (fPadHits && gAlice->TreeH() && cH) {
571 MakeBranchInTree(gAlice->TreeH(),
572 branchname, &fPadHits, kBufferSize, file);
573 }
574
575 if (cD) {
576 //
577 // one branch for digits per chamber
578 //
579 Int_t i;
580
581 for (i=0; i<AliMUONConstants::NCh() ;i++) {
582 sprintf(branchname,"%sDigits%d",GetName(),i+1);
583 if (fDchambers && gAlice->TreeD()) {
584 MakeBranchInTree(gAlice->TreeD(),
585 branchname, &((*fDchambers)[i]), kBufferSize, file);
586 printf("Making Branch %s for digits in chamber %d\n",branchname,i+1);
587 }
588 }
589 }
590
591 if (cR) {
592 //
593 // one branch for raw clusters per chamber
594 //
595 printf("Make Branch - TreeR address %p\n",gAlice->TreeR());
596
597 Int_t i;
598
599 for (i=0; i<AliMUONConstants::NTrackingCh() ;i++) {
600 sprintf(branchname,"%sRawClusters%d",GetName(),i+1);
601 if (fRawClusters && gAlice->TreeR()) {
602 MakeBranchInTree(gAlice->TreeR(),
603 branchname, &((*fRawClusters)[i]), kBufferSize, file);
604 printf("Making Branch %s for raw clusters in chamber %d\n",branchname,i+1);
605 }
606 }
607 //
608 // one branch for global trigger
609 //
610 sprintf(branchname,"%sGlobalTrigger",GetName());
611 if (fGlobalTrigger && gAlice->TreeR()) {
612 MakeBranchInTree(gAlice->TreeR(),
613 branchname, &fGlobalTrigger, kBufferSize, file);
614 printf("Making Branch %s for Global Trigger\n",branchname);
615 }
616 //
617 // one branch for local trigger
618 //
619 sprintf(branchname,"%sLocalTrigger",GetName());
620 if (fLocalTrigger && gAlice->TreeR()) {
621 MakeBranchInTree(gAlice->TreeR(),
622 branchname, &fLocalTrigger, kBufferSize, file);
623 printf("Making Branch %s for Local Trigger\n",branchname);
624 }
625 }
626}
627
628//___________________________________________
629void AliMUON::SetTreeAddress()
630{
631 // Set branch address for the Hits and Digits Tree.
632 char branchname[30];
633 AliDetector::SetTreeAddress();
634
635 TBranch *branch;
636 TTree *treeH = gAlice->TreeH();
637 TTree *treeD = gAlice->TreeD();
638 TTree *treeR = gAlice->TreeR();
639
640 if (treeH) {
641 if (fPadHits) {
642 branch = treeH->GetBranch("MUONCluster");
643 if (branch) branch->SetAddress(&fPadHits);
644 }
645 }
646
647 if (treeD) {
648 for (int i=0; i<AliMUONConstants::NCh(); i++) {
649 sprintf(branchname,"%sDigits%d",GetName(),i+1);
650 if (fDchambers) {
651 branch = treeD->GetBranch(branchname);
652 if (branch) branch->SetAddress(&((*fDchambers)[i]));
653 }
654 }
655 }
656
657 // printf("SetTreeAddress --- treeR address %p \n",treeR);
658
659 if (treeR) {
660 for (int i=0; i<AliMUONConstants::NTrackingCh(); i++) {
661 sprintf(branchname,"%sRawClusters%d",GetName(),i+1);
662 if (fRawClusters) {
663 branch = treeR->GetBranch(branchname);
664 if (branch) branch->SetAddress(&((*fRawClusters)[i]));
665 }
666 }
667
668 if (fLocalTrigger) {
669 branch = treeR->GetBranch("MUONLocalTrigger");
670 if (branch) branch->SetAddress(&fLocalTrigger);
671 }
672 if (fGlobalTrigger) {
673 branch = treeR->GetBranch("MUONGlobalTrigger");
674 if (branch) branch->SetAddress(&fGlobalTrigger);
675 }
676 }
677}
678//___________________________________________
679void AliMUON::ResetHits()
680{
681 // Reset number of clusters and the cluster array for this detector
682 AliDetector::ResetHits();
683 fNPadHits = 0;
684 if (fPadHits) fPadHits->Clear();
685}
686
687//____________________________________________
688void AliMUON::ResetDigits()
689{
690 //
691 // Reset number of digits and the digits array for this detector
692 //
693 for ( int i=0;i<AliMUONConstants::NCh();i++ ) {
694 //PH if ((*fDchambers)[i]) ((TClonesArray*)(*fDchambers)[i])->Clear();
695 if ((*fDchambers)[i]) ((TClonesArray*)fDchambers->At(i))->Clear();
696 if (fNdch) fNdch[i]=0;
697 }
698}
699//____________________________________________
700void AliMUON::ResetRawClusters()
701{
702 //
703 // Reset number of raw clusters and the raw clust array for this detector
704 //
705 for ( int i=0;i<AliMUONConstants::NTrackingCh();i++ ) {
706 //PH if ((*fRawClusters)[i]) ((TClonesArray*)(*fRawClusters)[i])->Clear();
707 if ((*fRawClusters)[i]) ((TClonesArray*)fRawClusters->At(i))->Clear();
708 if (fNrawch) fNrawch[i]=0;
709 }
710}
711
712//____________________________________________
713void AliMUON::ResetTrigger()
714{
715 // Reset Local and Global Trigger
716 fNGlobalTrigger = 0;
717 if (fGlobalTrigger) fGlobalTrigger->Clear();
718 fNLocalTrigger = 0;
719 if (fLocalTrigger) fLocalTrigger->Clear();
720}
721
722//____________________________________________
723void AliMUON::SetPadSize(Int_t id, Int_t isec, Float_t p1, Float_t p2)
724{
725// Set the pad size for chamber id and cathode isec
726 Int_t i=2*(id-1);
727 //PH ((AliMUONChamber*) (*fChambers)[i]) ->SetPadSize(isec,p1,p2);
728 //PH ((AliMUONChamber*) (*fChambers)[i+1])->SetPadSize(isec,p1,p2);
729 ((AliMUONChamber*) fChambers->At(i)) ->SetPadSize(isec,p1,p2);
730 ((AliMUONChamber*) fChambers->At(i+1))->SetPadSize(isec,p1,p2);
731}
732
733//___________________________________________
734void AliMUON::SetChambersZ(const Float_t *Z)
735{
736 // Set Z values for all chambers (tracking and trigger)
737 // from the array pointed to by "Z"
738 for (Int_t ch = 0; ch < AliMUONConstants::NCh(); ch++)
739 //PH ((AliMUONChamber*) ((*fChambers)[ch]))->SetZ(Z[ch]);
740 ((AliMUONChamber*) fChambers->At(ch))->SetZ(Z[ch]);
741 return;
742}
743
744//___________________________________________
745void AliMUON::SetChambersZToDefault()
746{
747 // Set Z values for all chambers (tracking and trigger)
748 // to default values
749 SetChambersZ(AliMUONConstants::DefaultChamberZ());
750 return;
751}
752
753//___________________________________________
754void AliMUON::SetChargeSlope(Int_t id, Float_t p1)
755{
756// Set the inverse charge slope for chamber id
757 Int_t i=2*(id-1);
758 //PH ((AliMUONChamber*) (*fChambers)[i])->SetChargeSlope(p1);
759 //PH ((AliMUONChamber*) (*fChambers)[i+1])->SetChargeSlope(p1);
760 ((AliMUONChamber*) fChambers->At(i))->SetChargeSlope(p1);
761 ((AliMUONChamber*) fChambers->At(i+1))->SetChargeSlope(p1);
762}
763
764//___________________________________________
765void AliMUON::SetChargeSpread(Int_t id, Float_t p1, Float_t p2)
766{
767// Set sigma of charge spread for chamber id
768 Int_t i=2*(id-1);
769 //PH ((AliMUONChamber*) fChambers->At(i))->SetChargeSpread(p1,p2);
770 //PH ((AliMUONChamber*) fChambers->Ati+1])->SetChargeSpread(p1,p2);
771 ((AliMUONChamber*) fChambers->At(i))->SetChargeSpread(p1,p2);
772 ((AliMUONChamber*) fChambers->At(i+1))->SetChargeSpread(p1,p2);
773}
774
775//___________________________________________
776void AliMUON::SetSigmaIntegration(Int_t id, Float_t p1)
777{
778// Set integration limits for charge spread
779 Int_t i=2*(id-1);
780 //PH ((AliMUONChamber*) (*fChambers)[i])->SetSigmaIntegration(p1);
781 //PH ((AliMUONChamber*) (*fChambers)[i+1])->SetSigmaIntegration(p1);
782 ((AliMUONChamber*) fChambers->At(i))->SetSigmaIntegration(p1);
783 ((AliMUONChamber*) fChambers->At(i+1))->SetSigmaIntegration(p1);
784}
785
786//___________________________________________
787void AliMUON::SetMaxAdc(Int_t id, Int_t p1)
788{
789// Set maximum number for ADCcounts (saturation)
790 Int_t i=2*(id-1);
791 //PH ((AliMUONChamber*) (*fChambers)[i])->SetMaxAdc(p1);
792 //PH ((AliMUONChamber*) (*fChambers)[i+1])->SetMaxAdc(p1);
793 ((AliMUONChamber*) fChambers->At(i))->SetMaxAdc(p1);
794 ((AliMUONChamber*) fChambers->At(i+1))->SetMaxAdc(p1);
795}
796
797//___________________________________________
798void AliMUON::SetMaxStepGas(Float_t p1)
799{
800// Set stepsize in gas
801 fMaxStepGas=p1;
802}
803
804//___________________________________________
805void AliMUON::SetMaxStepAlu(Float_t p1)
806{
807// Set step size in Alu
808 fMaxStepAlu=p1;
809}
810
811//___________________________________________
812void AliMUON::SetMaxDestepGas(Float_t p1)
813{
814// Set maximum step size in Gas
815 fMaxDestepGas=p1;
816}
817
818//___________________________________________
819void AliMUON::SetMaxDestepAlu(Float_t p1)
820{
821// Set maximum step size in Alu
822 fMaxDestepAlu=p1;
823}
824//___________________________________________
825void AliMUON::SetAcceptance(Bool_t acc, Float_t angmin, Float_t angmax)
826{
827// Set acceptance cuts
828 fAccCut=acc;
829 fAccMin=angmin*TMath::Pi()/180;
830 fAccMax=angmax*TMath::Pi()/180;
831 Int_t ch;
832 if (acc) {
833 for (Int_t st = 0; st < AliMUONConstants::NCh() / 2; st++) {
834 // Loop over 2 chambers in the station
835 for (Int_t stCH = 0; stCH < 2; stCH++) {
836 ch = 2 * st + stCH;
837// Set chamber inner and outer radius according to acceptance cuts
838 Chamber(ch).SetRInner(AliMUONConstants::DefaultChamberZ(ch)*TMath::Tan(fAccMin));
839 Chamber(ch).SetROuter(AliMUONConstants::DefaultChamberZ(ch)*TMath::Tan(fAccMax));
840 } // chamber loop
841 } // station loop
842 }
843}
844//___________________________________________
845void AliMUON::SetSegmentationModel(Int_t id, Int_t isec, AliSegmentation *segmentation)
846{
847// Set the segmentation for chamber id cathode isec
848 //PH ((AliMUONChamber*) (*fChambers)[id])->SetSegmentationModel(isec, segmentation);
849 ((AliMUONChamber*) fChambers->At(id))->SetSegmentationModel(isec, segmentation);
850
851}
852//___________________________________________
853void AliMUON::SetResponseModel(Int_t id, AliMUONResponse *response)
854{
855// Set the response for chamber id
856 //PH ((AliMUONChamber*) (*fChambers)[id])->SetResponseModel(response);
857 ((AliMUONChamber*) fChambers->At(id))->SetResponseModel(response);
858}
859
860void AliMUON::SetReconstructionModel(Int_t id, AliMUONClusterFinderVS *reconst)
861{
862// Set ClusterFinder for chamber id
863 //PH ((AliMUONChamber*) (*fChambers)[id])->SetReconstructionModel(reconst);
864 ((AliMUONChamber*) fChambers->At(id))->SetReconstructionModel(reconst);
865}
866
867void AliMUON::SetNsec(Int_t id, Int_t nsec)
868{
869// Set number of segmented cathods for chamber id
870 //PH ((AliMUONChamber*) (*fChambers)[id])->SetNsec(nsec);
871 ((AliMUONChamber*) fChambers->At(id))->SetNsec(nsec);
872}
873
874//___________________________________________
875void AliMUON::SDigits2Digits()
876{
877
878// write TreeD here
879
880 if (!fMerger) {
881 if (gAlice->GetDebug()>0) {
882 cerr<<"AliMUON::SDigits2Digits: create default AliMUONMerger "<<endl;
883 cerr<<" no merging, just digitization of 1 event will be done"<<endl;
884 }
885 fMerger = new AliMUONMerger();
886 }
887 fMerger->Init();
888 fMerger->Digitise();
889 char hname[30];
890 sprintf(hname,"TreeD%d",gAlice->GetHeader()->GetEvent());
891 gAlice->TreeD()->Write(hname,TObject::kOverwrite);
892 gAlice->TreeD()->Reset();
893}
894
895//___________________________________________
896void AliMUON::MakePadHits(Float_t xhit,Float_t yhit, Float_t zhit,
897 Float_t eloss, Float_t tof, Int_t idvol)
898{
899//
900// Calls the charge disintegration method of the current chamber and adds
901// the simulated cluster to the root treee
902//
903 Int_t clhits[7];
904 Float_t newclust[6][500];
905 Int_t nnew;
906
907
908//
909// Integrated pulse height on chamber
910
911
912 clhits[0]=fNhits+1;
913//
914//
915// if (idvol == 6) printf("\n ->Disintegration %f %f %f", xhit, yhit, eloss );
916
917
918 //PH ((AliMUONChamber*) (*fChambers)[idvol])
919 ((AliMUONChamber*) fChambers->At(idvol))
920 ->DisIntegration(eloss, tof, xhit, yhit, zhit, nnew, newclust);
921 Int_t ic=0;
922// if (idvol == 6) printf("\n nnew %d \n", nnew);
923//
924// Add new clusters
925 for (Int_t i=0; i<nnew; i++) {
926 if (Int_t(newclust[3][i]) > 0) {
927 ic++;
928// Cathode plane
929 clhits[1] = Int_t(newclust[5][i]);
930// Cluster Charge
931 clhits[2] = Int_t(newclust[0][i]);
932// Pad: ix
933 clhits[3] = Int_t(newclust[1][i]);
934// Pad: iy
935 clhits[4] = Int_t(newclust[2][i]);
936// Pad: charge
937 clhits[5] = Int_t(newclust[3][i]);
938// Pad: chamber sector
939 clhits[6] = Int_t(newclust[4][i]);
940
941 AddPadHit(clhits);
942 }
943 }
944}
945
946//___________________________________________
947void AliMUON::Trigger(Int_t nev){
948// call the Trigger Algorithm and fill TreeR
949
950 Int_t singlePlus[3] = {0,0,0};
951 Int_t singleMinus[3] = {0,0,0};
952 Int_t singleUndef[3] = {0,0,0};
953 Int_t pairUnlike[3] = {0,0,0};
954 Int_t pairLike[3] = {0,0,0};
955
956 ResetTrigger();
957 AliMUONTriggerDecision* decision= new AliMUONTriggerDecision(1);
958 decision->Trigger();
959 decision->GetGlobalTrigger(singlePlus, singleMinus, singleUndef,
960 pairUnlike, pairLike);
961// add a local trigger in the list
962 AddGlobalTrigger(singlePlus, singleMinus, singleUndef, pairUnlike, pairLike);
963 Int_t i;
964
965 for (Int_t icirc=0; icirc<AliMUONConstants::NTriggerCircuit(); icirc++) {
966 if(decision->GetITrigger(icirc)==1) {
967 Int_t localtr[7]={0,0,0,0,0,0,0};
968 Int_t loLpt[2]={0,0}; Int_t loHpt[2]={0,0}; Int_t loApt[2]={0,0};
969 decision->GetLutOutput(icirc, loLpt, loHpt, loApt);
970 localtr[0] = icirc;
971 localtr[1] = decision->GetStripX11(icirc);
972 localtr[2] = decision->GetDev(icirc);
973 localtr[3] = decision->GetStripY11(icirc);
974 for (i=0; i<2; i++) { // convert the Lut output in 1 digit
975 localtr[4] = localtr[4]+Int_t(loLpt[i]*TMath::Power(2,i));
976 localtr[5] = localtr[5]+Int_t(loHpt[i]*TMath::Power(2,i));
977 localtr[6] = localtr[6]+Int_t(loApt[i]*TMath::Power(2,i));
978 }
979 AddLocalTrigger(localtr); // add a local trigger in the list
980 }
981 }
982 delete decision;
983
984 gAlice->TreeR()->Fill();
985 ResetTrigger();
986 char hname[30];
987 sprintf(hname,"TreeR%d",nev);
988 gAlice->TreeR()->Write(hname,TObject::kOverwrite);
989 gAlice->TreeR()->Reset();
990 printf("\n End of trigger for event %d", nev);
991}
992
993
994//____________________________________________
995void AliMUON::Digits2Reco()
996{
997 FindClusters();
998 Int_t nev = gAlice->GetHeader()->GetEvent();
999 gAlice->TreeR()->Fill();
1000 char hname[30];
1001 sprintf(hname,"TreeR%d", nev);
1002 gAlice->TreeR()->Write(hname);
1003 gAlice->TreeR()->Reset();
1004 ResetRawClusters();
1005 printf("\n End of cluster finding for event %d", nev);
1006}
1007
1008void AliMUON::FindClusters()
1009{
1010//
1011// Perform cluster finding
1012//
1013 TClonesArray *dig1, *dig2;
1014 Int_t ndig, k;
1015 dig1 = new TClonesArray("AliMUONDigit",1000);
1016 dig2 = new TClonesArray("AliMUONDigit",1000);
1017 AliMUONDigit *digit;
1018//
1019// Loop on chambers and on cathode planes
1020//
1021 ResetRawClusters();
1022 for (Int_t ich = 0; ich < 10; ich++) {
1023 //PH AliMUONChamber* iChamber = (AliMUONChamber*) (*fChambers)[ich];
1024 AliMUONChamber* iChamber = (AliMUONChamber*) fChambers->At(ich);
1025 AliMUONClusterFinderVS* rec = iChamber->ReconstructionModel();
1026
1027 gAlice->ResetDigits();
1028 gAlice->TreeD()->GetEvent(0);
1029 TClonesArray *muonDigits = this->DigitsAddress(ich);
1030 ndig=muonDigits->GetEntriesFast();
1031 printf("\n 1 Found %d digits in %p %d", ndig, muonDigits,ich);
1032 TClonesArray &lhits1 = *dig1;
1033 Int_t n = 0;
1034 for (k = 0; k < ndig; k++) {
1035 digit = (AliMUONDigit*) muonDigits->UncheckedAt(k);
1036 if (rec->TestTrack(digit->Track(0)))
1037 new(lhits1[n++]) AliMUONDigit(*digit);
1038 }
1039 gAlice->ResetDigits();
1040 gAlice->TreeD()->GetEvent(1);
1041 muonDigits = this->DigitsAddress(ich);
1042 ndig=muonDigits->GetEntriesFast();
1043 printf("\n 2 Found %d digits in %p %d", ndig, muonDigits, ich);
1044 TClonesArray &lhits2 = *dig2;
1045 n=0;
1046
1047 for (k=0; k<ndig; k++) {
1048 digit= (AliMUONDigit*) muonDigits->UncheckedAt(k);
1049 if (rec->TestTrack(digit->Track(0)))
1050 new(lhits2[n++]) AliMUONDigit(*digit);
1051 }
1052
1053 if (rec) {
1054 AliMUONClusterInput::Instance()->SetDigits(ich, dig1, dig2);
1055 rec->FindRawClusters();
1056 }
1057 dig1->Delete();
1058 dig2->Delete();
1059 } // for ich
1060 delete dig1;
1061 delete dig2;
1062}
1063
1064#ifdef never
1065void AliMUON::Streamer(TBuffer &R__b)
1066{
1067 // Stream an object of class AliMUON.
1068 AliMUONChamber *iChamber;
1069 AliMUONTriggerCircuit *iTriggerCircuit;
1070 AliSegmentation *segmentation;
1071 AliMUONResponse *response;
1072 TClonesArray *digitsaddress;
1073 TClonesArray *rawcladdress;
1074 Int_t i;
1075 if (R__b.IsReading()) {
1076 Version_t R__v = R__b.ReadVersion(); if (R__v) { }
1077 AliDetector::Streamer(R__b);
1078 R__b >> fNPadHits;
1079 R__b >> fPadHits; // diff
1080 R__b >> fNLocalTrigger;
1081 R__b >> fLocalTrigger;
1082 R__b >> fNGlobalTrigger;
1083 R__b >> fGlobalTrigger;
1084 R__b >> fDchambers;
1085 R__b >> fRawClusters;
1086 R__b.ReadArray(fNdch);
1087 R__b.ReadArray(fNrawch);
1088 R__b >> fAccCut;
1089 R__b >> fAccMin;
1090 R__b >> fAccMax;
1091 R__b >> fChambers;
1092 R__b >> fTriggerCircuits;
1093 for (i =0; i<AliMUONConstants::NTriggerCircuit(); i++) {
1094 iTriggerCircuit=(AliMUONTriggerCircuit*) (*fTriggerCircuits)[i];
1095 iTriggerCircuit->Streamer(R__b);
1096 }
1097// Stream chamber related information
1098 for (i =0; i<AliMUONConstants::NCh(); i++) {
1099 iChamber=(AliMUONChamber*) (*fChambers)[i];
1100 iChamber->Streamer(R__b);
1101 if (iChamber->Nsec()==1) {
1102 segmentation=iChamber->SegmentationModel(1);
1103 if (segmentation)
1104 segmentation->Streamer(R__b);
1105 } else {
1106 segmentation=iChamber->SegmentationModel(1);
1107 if (segmentation)
1108 segmentation->Streamer(R__b);
1109 if (segmentation)
1110 segmentation=iChamber->SegmentationModel(2);
1111 segmentation->Streamer(R__b);
1112 }
1113 response=iChamber->ResponseModel();
1114 if (response)
1115 response->Streamer(R__b);
1116 digitsaddress=(TClonesArray*) (*fDchambers)[i];
1117 digitsaddress->Streamer(R__b);
1118 if (i < AliMUONConstants::NTrackingCh()) {
1119 rawcladdress=(TClonesArray*) (*fRawClusters)[i];
1120 rawcladdress->Streamer(R__b);
1121 }
1122 }
1123
1124 } else {
1125 R__b.WriteVersion(AliMUON::IsA());
1126 AliDetector::Streamer(R__b);
1127 R__b << fNPadHits;
1128 R__b << fPadHits; // diff
1129 R__b << fNLocalTrigger;
1130 R__b << fLocalTrigger;
1131 R__b << fNGlobalTrigger;
1132 R__b << fGlobalTrigger;
1133 R__b << fDchambers;
1134 R__b << fRawClusters;
1135 R__b.WriteArray(fNdch, AliMUONConstants::NCh());
1136 R__b.WriteArray(fNrawch, AliMUONConstants::NTrackingCh());
1137
1138 R__b << fAccCut;
1139 R__b << fAccMin;
1140 R__b << fAccMax;
1141
1142 R__b << fChambers;
1143 R__b << fTriggerCircuits;
1144 for (i =0; i<AliMUONConstants::NTriggerCircuit(); i++) {
1145 iTriggerCircuit=(AliMUONTriggerCircuit*) (*fTriggerCircuits)[i];
1146 iTriggerCircuit->Streamer(R__b);
1147 }
1148 for (i =0; i<AliMUONConstants::NCh(); i++) {
1149 iChamber=(AliMUONChamber*) (*fChambers)[i];
1150 iChamber->Streamer(R__b);
1151 if (iChamber->Nsec()==1) {
1152 segmentation=iChamber->SegmentationModel(1);
1153 if (segmentation)
1154 segmentation->Streamer(R__b);
1155 } else {
1156 segmentation=iChamber->SegmentationModel(1);
1157 if (segmentation)
1158 segmentation->Streamer(R__b);
1159 segmentation=iChamber->SegmentationModel(2);
1160 if (segmentation)
1161 segmentation->Streamer(R__b);
1162 }
1163 response=iChamber->ResponseModel();
1164 if (response)
1165 response->Streamer(R__b);
1166 digitsaddress=(TClonesArray*) (*fDchambers)[i];
1167 digitsaddress->Streamer(R__b);
1168 if (i < AliMUONConstants::NTrackingCh()) {
1169 rawcladdress=(TClonesArray*) (*fRawClusters)[i];
1170 rawcladdress->Streamer(R__b);
1171 }
1172 }
1173 }
1174}
1175#endif
1176
1177AliMUONPadHit* AliMUON::FirstPad(AliMUONHit* hit, TClonesArray *clusters)
1178{
1179//
1180 // Initialise the pad iterator
1181 // Return the address of the first padhit for hit
1182 TClonesArray *theClusters = clusters;
1183 Int_t nclust = theClusters->GetEntriesFast();
1184 if (nclust && hit->PHlast() > 0) {
1185 AliMUON::fMaxIterPad=hit->PHlast();
1186 AliMUON::fCurIterPad=hit->PHfirst();
1187 return (AliMUONPadHit*) clusters->UncheckedAt(AliMUON::fCurIterPad-1);
1188 } else {
1189 return 0;
1190 }
1191}
1192
1193AliMUONPadHit* AliMUON::NextPad(TClonesArray *clusters)
1194{
1195// Get next pad (in iterator)
1196//
1197 AliMUON::fCurIterPad++;
1198 if (AliMUON::fCurIterPad <= AliMUON::fMaxIterPad) {
1199 return (AliMUONPadHit*) clusters->UncheckedAt(AliMUON::fCurIterPad-1);
1200 } else {
1201 return 0;
1202 }
1203}
1204
1205
1206AliMUONRawCluster *AliMUON::RawCluster(Int_t ichamber, Int_t icathod, Int_t icluster)
1207{
1208//
1209// Return rawcluster (icluster) for chamber ichamber and cathode icathod
1210// Obsolete ??
1211 TClonesArray *muonRawCluster = RawClustAddress(ichamber);
1212 ResetRawClusters();
1213 TTree *treeR = gAlice->TreeR();
1214 Int_t nent=(Int_t)treeR->GetEntries();
1215 treeR->GetEvent(nent-2+icathod-1);
1216 //treeR->GetEvent(icathod);
1217 //Int_t nrawcl = (Int_t)muonRawCluster->GetEntriesFast();
1218
1219 AliMUONRawCluster * mRaw = (AliMUONRawCluster*)muonRawCluster->UncheckedAt(icluster);
1220 //printf("RawCluster _ nent nrawcl icluster mRaw %d %d %d%p\n",nent,nrawcl,icluster,mRaw);
1221
1222 return mRaw;
1223}
1224
1225void AliMUON::SetMerger(AliMUONMerger* merger)
1226{
1227// Set pointer to merger
1228 fMerger = merger;
1229}
1230
1231AliMUONMerger* AliMUON::Merger()
1232{
1233// Return pointer to merger
1234 return fMerger;
1235}
1236
1237
1238
1239AliMUON& AliMUON::operator = (const AliMUON& rhs)
1240{
1241// copy operator
1242// dummy version
1243 return *this;
1244}
1245
1246////////////////////////////////////////////////////////////////////////
1247void AliMUON::MakeBranchInTreeD(TTree *treeD, const char *file)
1248{
1249 //
1250 // Create TreeD branches for the MUON.
1251 //
1252
1253 const Int_t kBufferSize = 4000;
1254 char branchname[30];
1255
1256 //
1257 // one branch for digits per chamber
1258 //
1259 for (Int_t i=0; i<AliMUONConstants::NCh() ;i++) {
1260 sprintf(branchname,"%sDigits%d",GetName(),i+1);
1261 if (fDchambers && treeD) {
1262 MakeBranchInTree(treeD,
1263 branchname, &((*fDchambers)[i]), kBufferSize, file);
1264// printf("Making Branch %s for digits in chamber %d\n",branchname,i+1);
1265 }
1266 }
1267}
1268
1269//___________________________________________
1270