Fixed some coding convention violations
[u/mrichter/AliRoot.git] / FMD / AliFMD.cxx
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
18 //////////////////////////////////////////////////////////////////////////////
19 //                                                                          
20 // Forward Multiplicity Detector based on Silicon wafers. This class
21 // contains the base procedures for the Forward Multiplicity detector
22 // Detector consists of 5 Si volumes covered pseudorapidity interval
23 // from 1.7 to 5.1.
24 //                                                       
25 // This is the base class for all FMD manager classes. 
26 //                    
27 // The actual code is done by various separate classes.   Below is
28 // diagram showing the relationship between the various FMD classes
29 // that handles the geometry 
30 //
31 //
32 //       +----------+   +----------+   
33 //       | AliFMDv1 |   | AliFMDv1 |   
34 //       +----------+   +----------+   
35 //            |              |
36 //       +----+--------------+
37 //       |
38 //       |           +------------+ 1  +---------------+
39 //       |        +- | AliFMDRing |<>--| AliFMDPolygon | 
40 //       V     2  |  +------------+    +---------------+   
41 //  +--------+<>--+        |
42 //  | AliFMD |             ^                       
43 //  +--------+<>--+        V 1..2                     
44 //             3  | +-------------------+ 
45 //                +-| AliFMDSubDetector | 
46 //                  +-------------------+
47 //                           ^              
48 //                           |
49 //             +-------------+-------------+
50 //             |             |             |          
51 //        +---------+   +---------+   +---------+
52 //        | AliFMD1 |   | AliFMD2 |   | AliFMD3 |
53 //        +---------+   +---------+   +---------+
54 //      
55 //
56 // *  AliFMD 
57 //    This defines the interface for the various parts of AliROOT that
58 //    uses the FMD, like AliFMDDigitizer, AliFMDReconstructor, and so
59 //    on. 
60 //
61 // *  AliFMDv1 
62 //    This is a concrete implementation of the AliFMD interface. 
63 //    It is the responsibility of this class to create the FMD
64 //    geometry, process hits in the FMD, and serve hits and digits to
65 //    the various clients. 
66 //  
67 //    It uses the objects of class AliFMDSubDetector to do the various
68 //    stuff for FMD1, 2, and 3 
69 //
70 // *  AliFMDRing 
71 //    This class contains all stuff needed to do with a ring.  It's
72 //    used by the AliFMDSubDetector objects to instantise inner and
73 //    outer rings.  The AliFMDRing objects are shared by the
74 //    AliFMDSubDetector objects, and owned by the AliFMDv1 object. 
75 //
76 // *  AliFMDPolygon 
77 //    The code I lifted from TGeoPolygon to help with the geometry of
78 //    the modules, as well as to decide wether a hit is actually with
79 //    in the real module shape.  The point is, that the shape of the
80 //    various ring modules are really polygons (much like the lid of a
81 //    coffin), but it's segmented at constant radius.  That is very
82 //    hard to implement using GEANT 3.21 shapes, so instead the
83 //    modules are implemented as TUBS (tube sections), and in the step
84 //    procedure we do the test whether the track was inside the real
85 //    shape of the module.  
86 //
87 // *  AliFMD1, AliFMD2, and AliFMD3 
88 //    These are specialisation of AliFMDSubDetector, that contains the
89 //    particularities of each of the sub-detector system.  It is
90 //    envisioned that the classes should also define the support
91 //    volumes and material for each of the detectors.                          
92 //                                                                          
93 // The responsible person for this module is Alla Maevskaia
94 // <Alla.Maevskaia@cern.ch>.
95 //
96 // Many modifications by Christian Holm Christensen <cholm@nbi.dk>
97 //
98
99 #ifndef ROOT_TClonesArray
100 #include <TClonesArray.h>
101 #endif
102 #ifndef ROOT_TGeomtry
103 # include <TGeometry.h>
104 #endif
105 #ifndef ROOT_TNode
106 # include <TNode.h>
107 #endif
108 #ifndef ROOT_TTUBE
109 # include <TTUBE.h>
110 #endif
111 #ifndef ROOT_TTree
112 # include <TTree.h>
113 #endif
114 #ifndef ROOT_TVirtualMC
115 # include <TVirtualMC.h>
116 #endif
117 #ifndef ROOT_TBrowser
118 # include <TBrowser.h>
119 #endif
120 #ifndef ROOT_TMath
121 # include <TMath.h>
122 #endif
123
124 #ifndef ALIRUNDIGITIZER_H
125 # include "AliRunDigitizer.h"
126 #endif
127 #ifndef ALILOADER_H
128 # include "AliLoader.h"
129 #endif
130 #ifndef ALIRUN_H
131 # include "AliRun.h"
132 #endif
133 #ifndef ALIMC_H
134 # include "AliMC.h"
135 #endif
136 #ifndef ALILOG_H
137 # include "AliLog.h"
138 #endif
139 #ifndef ALIMAGF_H
140 # include "AliMagF.h"
141 #endif
142 #ifndef ALIFMD_H
143 # include "AliFMD.h"
144 #endif
145 #ifndef ALIFMDDIGIG_H
146 # include "AliFMDDigit.h"
147 #endif
148 #ifndef ALIFMDHIT_H
149 # include "AliFMDHit.h"
150 #endif
151 #ifndef ALIFMDDIGITIZER_H
152 # include "AliFMDDigitizer.h"
153 #endif
154 #ifndef ALIFMD1_H
155 # include "AliFMD1.h"
156 #endif
157 #ifndef ALIFMD2_H
158 # include "AliFMD2.h"
159 #endif
160 #ifndef ALIFMD3_H
161 # include "AliFMD3.h"
162 #endif
163 #ifndef ALIALTROBUFFER_H
164 # include "AliAltroBuffer.h"
165 #endif
166
167 //____________________________________________________________________
168 ClassImp(AliFMD);
169
170 //____________________________________________________________________
171 AliFMD::AliFMD()
172   : fInner(0), 
173     fOuter(0),
174     fFMD1(0),
175     fFMD2(0), 
176     fFMD3(0)
177 {
178   //
179   // Default constructor for class AliFMD
180   //
181   AliDebug(0, "Default CTOR");
182   fHits     = 0;
183   fDigits   = 0;
184   fSDigits  = 0;
185   fNsdigits = 0;
186   fIshunt   = 0;
187 }
188
189 //____________________________________________________________________
190 AliFMD::AliFMD(const char *name, const char *title, bool detailed)
191   : AliDetector (name, title),
192     fInner(0), 
193     fOuter(0),
194     fFMD1(0),
195     fFMD2(0), 
196     fFMD3(0)
197 {
198   //
199   // Standard constructor for Forward Multiplicity Detector
200   //
201   AliDebug(0, "Standard CTOR");
202
203   // Initialise Hit array
204   HitsArray();
205   gAlice->GetMCApp()->AddHitList(fHits);
206
207   // (S)Digits for the detectors disk
208   DigitsArray();
209   SDigitsArray();
210   
211   // CHC: What is this?
212   fIshunt = 0;
213   SetMarkerColor(kRed);
214   SetLineColor(kYellow);
215   SetSiDensity();
216
217   // Create sub-volume managers 
218   fInner = new AliFMDRing('I', detailed);
219   fOuter = new AliFMDRing('O', detailed);
220   fFMD1  = new AliFMD1();
221   fFMD2  = new AliFMD2();
222   fFMD3  = new AliFMD3();
223
224   // Specify parameters of sub-volume managers 
225   fFMD1->SetInner(fInner);
226   fFMD1->SetOuter(0);
227
228   fFMD2->SetInner(fInner);
229   fFMD2->SetOuter(fOuter);
230   
231   fFMD3->SetInner(fInner);
232   fFMD3->SetOuter(fOuter);
233
234   SetLegLength();
235   SetLegRadius();
236   SetLegOffset();
237   SetModuleSpacing();
238   
239   fInner->SetLowR(4.3);
240   fInner->SetHighR(17.2);
241   fInner->SetWaferRadius(13.4/2);
242   fInner->SetTheta(36/2);
243   fInner->SetNStrips(512);
244   fInner->SetSiThickness(.03);
245   fInner->SetPrintboardThickness(.11);
246   fInner->SetBondingWidth(.5);
247
248   fOuter->SetLowR(15.6);
249   fOuter->SetHighR(28.0);
250   fOuter->SetWaferRadius(13.4/2);
251   fOuter->SetTheta(18/2);
252   fOuter->SetNStrips( 256);
253   fOuter->SetSiThickness(.03);
254   fOuter->SetPrintboardThickness(.1);
255   fOuter->SetBondingWidth(.5);
256   
257   
258   fFMD1->SetHoneycombThickness(1);
259   fFMD1->SetInnerZ(340.0);
260   
261   fFMD2->SetHoneycombThickness(1);
262   fFMD2->SetInnerZ(83.4);
263   fFMD2->SetOuterZ(75.2);
264
265   fFMD3->SetHoneycombThickness(1);
266   fFMD3->SetInnerZ(-62.8);
267   fFMD3->SetOuterZ(-75.2);
268 }
269
270 //____________________________________________________________________
271 AliFMD::~AliFMD ()
272 {
273   // Destructor for base class AliFMD
274   if (fHits) {
275     fHits->Delete();
276     delete fHits;
277     fHits = 0;
278   }
279   if (fDigits) {
280     fDigits->Delete();
281     delete fDigits;
282     fDigits = 0;
283   }
284   if (fSDigits) {
285     fSDigits->Delete();
286     delete fSDigits;
287     fSDigits = 0;
288   }
289 }
290
291 //====================================================================
292 //
293 // GEometry ANd Traking
294 //
295 //____________________________________________________________________
296 void 
297 AliFMD::CreateGeometry()
298 {
299   //
300   // Create the geometry of Forward Multiplicity Detector.  The actual
301   // construction of the geometry is delegated to the class AliFMDRing
302   // and AliFMDSubDetector and the relevant derived classes. 
303   //
304   // The flow of this member function is:
305   //
306   //   FOR rings fInner and fOuter DO  
307   //     AliFMDRing::Init();
308   //   END FOR
309   // 
310   //   Set up hybrud card support (leg) volume shapes  
311   // 
312   //   FOR rings fInner and fOuter DO  
313   //     AliFMDRing::SetupGeometry();
314   //   END FOR
315   // 
316   //   FOR subdetectors fFMD1, fFMD2, and fFMD3 DO 
317   //     AliFMDSubDetector::SetupGeomtry();
318   //   END FOR
319   // 
320   //   FOR subdetectors fFMD1, fFMD2, and fFMD3 DO 
321   //     AliFMDSubDetector::Geomtry();
322   //   END FOR
323   //   
324
325   // DebugGuard guard("AliFMD::CreateGeometry");
326   AliDebug(10, "Creating geometry");
327
328   fInner->Init();
329   fOuter->Init();
330
331   TString name;
332   Double_t par[3];
333
334   par[0]      =  fLegRadius - .1;
335   par[1]      =  fLegRadius;
336   par[2]      =  fLegLength / 2;
337   name        =  "FSL";
338   fShortLegId =  gMC->Gsvolu(name.Data(),"TUBE",(*fIdtmed)[kPlasticId],par,3);
339   
340   par[2]      += fModuleSpacing / 2;
341   name        = "FLL";
342   fLongLegId  =  gMC->Gsvolu(name.Data(),"TUBE",(*fIdtmed)[kPlasticId],par,3);
343
344   fInner->SetupGeometry((*fIdtmed)[kAirId], 
345                         (*fIdtmed)[kSiId], 
346                         (*fIdtmed)[kPcbId], 
347                         fPrintboardRotationId, 
348                         fIdentityRotationId);
349   fOuter->SetupGeometry((*fIdtmed)[kAirId], 
350                         (*fIdtmed)[kSiId], 
351                         (*fIdtmed)[kPcbId], 
352                         fPrintboardRotationId, 
353                         fIdentityRotationId);
354
355   fFMD1->SetupGeometry((*fIdtmed)[kAirId], (*fIdtmed)[kKaptionId]);
356   fFMD2->SetupGeometry((*fIdtmed)[kAirId], (*fIdtmed)[kKaptionId]);
357   fFMD3->SetupGeometry((*fIdtmed)[kAirId], (*fIdtmed)[kKaptionId]);
358   
359   fFMD1->Geometry("ALIC", fPrintboardRotationId, fIdentityRotationId);
360   fFMD2->Geometry("ALIC", fPrintboardRotationId, fIdentityRotationId);
361   fFMD3->Geometry("ALIC", fPrintboardRotationId, fIdentityRotationId);    
362 }    
363
364 //____________________________________________________________________
365 void AliFMD::CreateMaterials() 
366 {
367   // Register various materials and tracking mediums with the
368   // backend.   
369   // 
370   // Currently defined materials and mediums are 
371   // 
372   //    FMD Air         Normal air 
373   //    FMD Si          Active silicon of sensors 
374   //    FMD Carbon      Normal carbon used in support, etc. 
375   //    FMD Kapton      Carbon used in Honeycomb
376   //    FMD PCB         Printed circuit board material 
377   //    FMD Plastic     Material for support legs 
378   // 
379   // Also defined are two rotation matricies. 
380   //
381   // DebugGuard guard("AliFMD::CreateMaterials");
382   AliDebug(10, "Creating materials");
383   Int_t    id;
384   Double_t a                = 0;
385   Double_t z                = 0;
386   Double_t density          = 0;
387   Double_t radiationLength  = 0;
388   Double_t absorbtionLength = 999;
389   Int_t    fieldType        = gAlice->Field()->Integ();     // Field type 
390   Double_t maxField         = gAlice->Field()->Max();     // Field max.
391   Double_t maxBending       = 0;     // Max Angle
392   Double_t maxStepSize      = 0.001; // Max step size 
393   Double_t maxEnergyLoss    = 1;     // Max Delta E
394   Double_t precision        = 0.001; // Precision
395   Double_t minStepSize      = 0.001; // Minimum step size 
396  
397   // Silicon 
398   a                = 28.0855;
399   z                = 14.;
400   density          = fSiDensity;
401   radiationLength  = 9.36;
402   maxBending       = 1;
403   maxStepSize      = .001;
404   precision        = .001;
405   minStepSize      = .001;
406   id               = kSiId;
407   AliMaterial(id, "FMD Si$", a, z, density, radiationLength, absorbtionLength);
408   AliMedium(kSiId, "FMD Si$",id,1,fieldType,maxField,maxBending,
409             maxStepSize,maxEnergyLoss,precision,minStepSize);
410
411
412   // Carbon 
413   a                = 12.011;
414   z                = 6.;
415   density          = 2.265;
416   radiationLength  = 18.8;
417   maxBending       = 10;
418   maxStepSize      = .01;
419   precision        = .003;
420   minStepSize      = .003;
421   id               = kCarbonId;
422   AliMaterial(id, "FMD Carbon$", a, z, density, radiationLength, 
423               absorbtionLength);
424   AliMedium(kCarbonId, "FMD Carbon$",id,0,fieldType,maxField,maxBending,
425             maxStepSize,maxEnergyLoss,precision,minStepSize);
426
427   // Silicon chip 
428   {
429     Float_t as[] = { 12.0107,      14.0067,      15.9994,
430                      1.00794,      28.0855,     107.8682 };
431     Float_t zs[] = {  6.,           7.,           8.,
432                       1.,          14.,          47. };
433     Float_t ws[] = {  0.039730642,  0.001396798,  0.01169634,
434                       0.004367771,  0.844665,     0.09814344903 };
435     density = 2.36436;
436     maxBending       = 10;
437     maxStepSize      = .01;
438     precision        = .003;
439     minStepSize      = .003;
440     id = kSiChipId;
441     AliMixture(id, "FMD Si Chip$", as, zs, density, 6, ws);
442     AliMedium(kSiChipId, "FMD Si Chip$", id, 0, fieldType, maxField, 
443               maxBending, maxStepSize, maxEnergyLoss, precision, minStepSize);
444   }
445   
446
447   // Kaption 
448   {
449     Float_t as[] = { 1.00794,  12.0107,  14.010,   15.9994};
450     Float_t zs[] = { 1.,        6.,       7.,       8.};
451     Float_t ws[] = { 0.026362,  0.69113,  0.07327,  0.209235};
452     density          = 1.42;
453     maxBending       = 1;
454     maxStepSize      = .001;
455     precision        = .001;
456     minStepSize      = .001;
457     id               = kKaptionId;
458     AliMixture(id, "FMD Kaption$", as, zs, density, 4, ws);
459     AliMedium(kKaptionId, "FMD Kaption$",id,0,fieldType,maxField,maxBending,
460               maxStepSize,maxEnergyLoss,precision,minStepSize);
461   }
462   
463   // Air
464   {
465     Float_t as[] = { 12.0107, 14.0067,   15.9994,  39.948 };
466     Float_t zs[] = {  6.,      7.,       8.,       18. };
467     Float_t ws[] = { 0.000124, 0.755267, 0.231781, 0.012827 }; 
468     density      = .00120479;
469     maxBending   = 1;
470     maxStepSize  = .001;
471     precision    = .001;
472     minStepSize  = .001;
473     id           = kAirId;
474     AliMixture(id, "FMD Air$", as, zs, density, 4, ws);
475     AliMedium(kAirId, "FMD Air$", id,0,fieldType,maxField,maxBending,
476               maxStepSize,maxEnergyLoss,precision,minStepSize);
477   }
478   
479   // PCB
480   {
481     Float_t zs[] = { 14.,         20.,         13.,         12.,
482                       5.,         22.,         11.,         19.,
483                      26.,          9.,          8.,          6.,
484                       7.,          1.};
485     Float_t as[] = { 28.0855,     40.078,      26.981538,   24.305, 
486                      10.811,      47.867,      22.98977,    39.0983,
487                      55.845,      18.9984,     15.9994,     12.0107,
488                      14.0067,      1.00794};
489     Float_t ws[] = {  0.15144894,  0.08147477,  0.04128158,  0.00904554, 
490                       0.01397570,  0.00287685,  0.00445114,  0.00498089,
491                       0.00209828,  0.00420000,  0.36043788,  0.27529426,
492                       0.01415852,  0.03427566};
493     density      = 1.8;
494     maxBending   = 1;
495     maxStepSize  = .001;
496     precision    = .001;
497     minStepSize  = .001;
498     id           = kPcbId;
499     AliMixture(id, "FMD PCB$", as, zs, density, 14, ws);
500     AliMedium(kPcbId, "FMD PCB$", id,1,fieldType,maxField,maxBending,
501               maxStepSize,maxEnergyLoss,precision,minStepSize);
502   }
503   
504   // Plastic 
505   {
506     Float_t as[] = { 1.01, 12.01 };
507     Float_t zs[] = { 1.,   6.    };
508     Float_t ws[] = { 1.,   1.    };
509     density      = 1.03;
510     maxBending   = 10;
511     maxStepSize  = .01;
512     precision    = .003;
513     minStepSize  = .003;
514     id           = kPlasticId;
515     AliMixture(id, "FMD Plastic$", as, zs, density, -2, ws);
516     AliMedium(kPlasticId, "FMD Plastic$", id,0,fieldType,maxField,maxBending,
517                 maxStepSize,maxEnergyLoss,precision,minStepSize);
518   }
519   AliMatrix(fPrintboardRotationId, 90, 90, 0, 90, 90, 0);
520   AliMatrix(fIdentityRotationId, 90, 0, 90, 90, 0, 0);
521 }
522
523 //____________________________________________________________________
524 void  
525 AliFMD::Init()
526 {
527   //
528   // Initialis the FMD after it has been built
529   Int_t i;
530   //
531   if (fDebug) {
532     std::cout << "\n" << ClassName() << ": " << std::flush;
533     for (i = 0; i < 35; i++) std::cout << "*";
534     std::cout << " FMD_INIT ";
535     for (i = 0; i < 35; i++) std::cout << "*";
536     std::cout << "\n" << ClassName() << ": " << std::flush;
537     //
538     // Here the FMD initialisation code (if any!)
539     for (i = 0; i < 80; i++) std::cout << "*";
540     std::cout << std::endl;
541   }
542   //
543   //
544 }
545
546 //====================================================================
547 //
548 // Graphics and event display
549 //
550 //____________________________________________________________________
551 void 
552 AliFMD::BuildGeometry()
553 {
554   //
555   // Build simple ROOT TNode geometry for event display
556   //
557   // Build a simplified geometry of the FMD used for event display  
558   // 
559   // The actual building of the TNodes is done by
560   // AliFMDSubDetector::SimpleGeometry. 
561   AliDebug(10, "Creating a simplified geometry");
562
563   TNode* top = gAlice->GetGeometry()->GetNode("alice");
564   
565   fFMD1->SimpleGeometry(fNodes, top, GetLineColor(), 0);
566   fFMD2->SimpleGeometry(fNodes, top, GetLineColor(), 0);
567   fFMD3->SimpleGeometry(fNodes, top, GetLineColor(), 0);
568 }
569
570 //____________________________________________________________________
571 void 
572 AliFMD::DrawDetector()
573 {
574   //
575   // Draw a shaded view of the Forward multiplicity detector
576   //
577   // DebugGuard guard("AliFMD::DrawDetector");
578   AliDebug(10, "Draw detector");
579   
580   //Set ALIC mother transparent
581   gMC->Gsatt("ALIC","SEEN",0);
582
583   //Set volumes visible
584   fFMD1->Gsatt();
585   fFMD2->Gsatt();
586   fFMD3->Gsatt();
587   fInner->Gsatt();
588   fOuter->Gsatt();
589
590   //
591   gMC->Gdopt("hide", "on");
592   gMC->Gdopt("shad", "on");
593   gMC->Gsatt("*", "fill", 7);
594   gMC->SetClipBox(".");
595   gMC->SetClipBox("*", 0, 1000, -1000, 1000, -1000, 1000);
596   gMC->DefaultRange();
597   gMC->Gdraw("alic", 40, 30, 0, 12, 12, .055, .055);
598   gMC->Gdhead(1111, "Forward Multiplicity Detector");
599   gMC->Gdman(16, 10, "MAN");
600   gMC->Gdopt("hide", "off");
601 }
602
603 //____________________________________________________________________
604 const Int_t 
605 AliFMD::DistanceToPrimitive(Int_t, Int_t)
606 {
607   //
608   // Calculate the distance from the mouse to the FMD on the screen
609   // Dummy routine
610   //
611   return 9999;
612 }
613
614 //====================================================================
615 //
616 // Hit and Digit managment 
617 //
618 //____________________________________________________________________
619 void 
620 AliFMD::MakeBranch(Option_t * option)
621 {
622   // Create Tree branches for the FMD.
623   //
624   // Options:
625   //
626   //    H          Make a branch of TClonesArray of AliFMDHit's
627   //    D          Make a branch of TClonesArray of AliFMDDigit's
628   //    S          Make a branch of TClonesArray of AliFMDSDigit's
629   // 
630   const Int_t kBufferSize = 16000;
631   TString branchname(GetName());
632   TString opt(option);
633   
634   if (opt.Contains("H", TString::kIgnoreCase)) {
635     HitsArray();
636     AliDetector::MakeBranch(option); 
637   }
638   if (opt.Contains("D", TString::kIgnoreCase)) { 
639     DigitsArray();
640     MakeBranchInTree(fLoader->TreeD(), branchname.Data(),
641                      &fDigits, kBufferSize, 0);
642   }
643   if (opt.Contains("S", TString::kIgnoreCase)) { 
644     SDigitsArray();
645     MakeBranchInTree(fLoader->TreeS(), branchname.Data(),
646                      &fSDigits, kBufferSize, 0);
647   }
648 }
649
650 //____________________________________________________________________
651 void 
652 AliFMD::SetTreeAddress()
653 {
654   // Set branch address for the Hits and Digits Tree.
655
656   if (fLoader->TreeH()) HitsArray();
657   AliDetector::SetTreeAddress();
658
659   TTree *treeD = fLoader->TreeD();
660   if (treeD) {
661     DigitsArray();
662     TBranch* branch = treeD->GetBranch ("FMD");
663     if (branch) branch->SetAddress(&fDigits);
664   }
665
666   TTree *treeS = fLoader->TreeS();
667   if (treeS) {
668     SDigitsArray();
669     TBranch* branch = treeS->GetBranch ("FMD");
670     if (branch) branch->SetAddress(&fSDigits);
671   }
672 }
673
674
675
676 //____________________________________________________________________
677 void 
678 AliFMD::SetHitsAddressBranch(TBranch *b)
679 {
680   // Set the TClonesArray to read hits into. 
681   b->SetAddress(&fHits);
682 }
683
684 //____________________________________________________________________
685 void 
686 AliFMD::AddHit(Int_t track, Int_t *vol, Float_t *hits) 
687 {
688   // Add a hit to the hits tree 
689   // 
690   // The information of the two arrays are decoded as 
691   // 
692   // Parameters
693   //    track                Track #
694   //    ivol[0]  [UShort_t ] Detector # 
695   //    ivol[1]  [Char_t   ] Ring ID 
696   //    ivol[2]  [UShort_t ] Sector #
697   //    ivol[3]  [UShort_t ] Strip # 
698   //    hits[0]  [Float_t  ] Track's X-coordinate at hit 
699   //    hits[1]  [Float_t  ] Track's Y-coordinate at hit
700   //    hits[3]  [Float_t  ] Track's Z-coordinate at hit
701   //    hits[4]  [Float_t  ] X-component of track's momentum             
702   //    hits[5]  [Float_t  ] Y-component of track's momentum             
703   //    hits[6]  [Float_t  ] Z-component of track's momentum            
704   //    hits[7]  [Float_t  ] Energy deposited by track                  
705   //    hits[8]  [Int_t    ] Track's particle Id # 
706   //    hits[9]  [Float_t  ] Time when the track hit
707   // 
708   // 
709   AddHit(track, 
710          UShort_t(vol[0]),  // Detector # 
711          Char_t(vol[1]),    // Ring ID
712          UShort_t(vol[2]),  // Sector # 
713          UShort_t(vol[3]),  // Strip # 
714          hits[0],           // X
715          hits[1],           // Y
716          hits[2],           // Z
717          hits[3],           // Px
718          hits[4],           // Py
719          hits[5],           // Pz
720          hits[6],           // Energy loss 
721          Int_t(hits[7]),    // PDG 
722          hits[8]);          // Time
723 }
724
725 //____________________________________________________________________
726 void 
727 AliFMD::AddHit(Int_t    track, 
728                UShort_t detector, 
729                Char_t   ring, 
730                UShort_t sector, 
731                UShort_t strip, 
732                Float_t  x, 
733                Float_t  y, 
734                Float_t  z,
735                Float_t  px, 
736                Float_t  py, 
737                Float_t  pz,
738                Float_t  edep,
739                Int_t    pdg,
740                Float_t  t)
741 {
742   //
743   // Add a hit to the list
744   //
745   // Parameters:
746   // 
747   //    track     Track #
748   //    detector  Detector # (1, 2, or 3)                      
749   //    ring      Ring ID ('I' or 'O')
750   //    sector    Sector # (For inner/outer rings: 0-19/0-39)
751   //    strip     Strip # (For inner/outer rings: 0-511/0-255)
752   //    x         Track's X-coordinate at hit
753   //    y         Track's Y-coordinate at hit
754   //    z         Track's Z-coordinate at hit
755   //    px        X-component of track's momentum 
756   //    py        Y-component of track's momentum
757   //    pz        Z-component of track's momentum
758   //    edep      Energy deposited by track
759   //    pdg       Track's particle Id #
760   //    t         Time when the track hit 
761   // 
762   TClonesArray& a = *(HitsArray());
763   // Search through the list of already registered hits, and see if we
764   // find a hit with the same parameters.  If we do, then don't create
765   // a new hit, but rather update the energy deposited in the hit.
766   // This is done, so that a FLUKA based simulation will get the
767   // number of hits right, not just the enerrgy deposition. 
768   for (Int_t i = 0; i < fNhits; i++) {
769     if (!a.At(i)) continue;
770     AliFMDHit* hit = static_cast<AliFMDHit*>(a.At(i));
771     if (hit->Detector() == detector 
772         && hit->Ring() == ring
773         && hit->Sector() == sector 
774         && hit->Strip() == strip
775         && hit->Track() == track) {
776       Warning("AddHit", "already had a hit in FMD%d%c[%2d,%3d] for track # %d,"
777               " adding energy (%f) to that hit (%f) -> %f", 
778               detector, ring, sector, strip, track, edep, hit->Edep(),
779               hit->Edep() + edep);
780       hit->SetEdep(hit->Edep() + edep);
781       return;
782     }
783   }
784   // If hit wasn't already registered, do so know. 
785   new (a[fNhits]) AliFMDHit(fIshunt, track, detector, ring, sector, strip, 
786                             x, y, z, px, py, pz, edep, pdg, t);
787   fNhits++;
788 }
789
790 //____________________________________________________________________
791 void 
792 AliFMD::AddDigit(Int_t* digits)
793 {
794   // Add a digit to the Digit tree 
795   // 
796   // Paramters 
797   //
798   //    digits[0]  [UShort_t] Detector #
799   //    digits[1]  [Char_t]   Ring ID
800   //    digits[2]  [UShort_t] Sector #
801   //    digits[3]  [UShort_t] Strip #
802   //    digits[4]  [UShort_t] ADC Count 
803   //    digits[5]  [Short_t]  ADC Count, -1 if not used
804   //    digits[6]  [Short_t]  ADC Count, -1 if not used 
805   // 
806   AddDigit(UShort_t(digits[0]),  // Detector #
807            Char_t(digits[1]),    // Ring ID
808            UShort_t(digits[2]),  // Sector #
809            UShort_t(digits[3]),  // Strip #
810            UShort_t(digits[4]),  // ADC Count1 
811            Short_t(digits[5]),   // ADC Count2 
812            Short_t(digits[6]));  // ADC Count3 
813 }
814
815 //____________________________________________________________________
816 void 
817 AliFMD::AddDigit(UShort_t detector, 
818                  Char_t   ring, 
819                  UShort_t sector, 
820                  UShort_t strip, 
821                  UShort_t count1, 
822                  Short_t  count2,
823                  Short_t  count3)
824 {
825   // add a real digit - as coming from data
826   // 
827   // Parameters 
828   //
829   //    detector  Detector # (1, 2, or 3)                      
830   //    ring      Ring ID ('I' or 'O')
831   //    sector    Sector # (For inner/outer rings: 0-19/0-39)
832   //    strip     Strip # (For inner/outer rings: 0-511/0-255)
833   //    count1    ADC count (a 10-bit word)
834   //    count2    ADC count (a 10-bit word), or -1 if not used
835   //    count3    ADC count (a 10-bit word), or -1 if not used
836   TClonesArray& a = *(DigitsArray());
837   
838   new (a[fNdigits++]) 
839     AliFMDDigit(detector, ring, sector, strip, count1, count2, count3);
840 }
841
842 //____________________________________________________________________
843 void 
844 AliFMD::AddSDigit(Int_t* digits)
845 {
846   // Add a digit to the SDigit tree 
847   // 
848   // Paramters 
849   //
850   //    digits[0]  [UShort_t] Detector #
851   //    digits[1]  [Char_t]   Ring ID
852   //    digits[2]  [UShort_t] Sector #
853   //    digits[3]  [UShort_t] Strip #
854   //    digits[4]  [Float_t]  Total energy deposited 
855   //    digits[5]  [UShort_t] ADC Count 
856   //    digits[6]  [Short_t]  ADC Count, -1 if not used
857   //    digits[7]  [Short_t]  ADC Count, -1 if not used 
858   // 
859   AddSDigit(UShort_t(digits[0]),  // Detector #
860             Char_t(digits[1]),    // Ring ID
861             UShort_t(digits[2]),  // Sector #
862             UShort_t(digits[3]),  // Strip #
863             Float_t(digits[4]),   // Edep
864             UShort_t(digits[5]),  // ADC Count1 
865             Short_t(digits[6]),   // ADC Count2 
866             Short_t(digits[7]));  // ADC Count3 
867 }
868
869 //____________________________________________________________________
870 void 
871 AliFMD::AddSDigit(UShort_t detector, 
872                   Char_t   ring, 
873                   UShort_t sector, 
874                   UShort_t strip, 
875                   Float_t  edep,
876                   UShort_t count1, 
877                   Short_t  count2,
878                   Short_t  count3)
879 {
880   // add a summable digit
881   // 
882   // Parameters 
883   //
884   //    detector  Detector # (1, 2, or 3)                      
885   //    ring      Ring ID ('I' or 'O')
886   //    sector    Sector # (For inner/outer rings: 0-19/0-39)
887   //    strip     Strip # (For inner/outer rings: 0-511/0-255)
888   //    edep      Total energy deposited
889   //    count1    ADC count (a 10-bit word)
890   //    count2    ADC count (a 10-bit word), or -1 if not used
891   //    count3    ADC count (a 10-bit word), or -1 if not used
892   //
893   TClonesArray& a = *(SDigitsArray());
894   
895   new (a[fNsdigits++]) 
896     AliFMDSDigit(detector, ring, sector, strip, edep, count1, count2, count3);
897 }
898
899 //____________________________________________________________________
900 void 
901 AliFMD::ResetSDigits()
902 {
903   //
904   // Reset number of digits and the digits array for this detector
905   //
906   fNsdigits   = 0;
907   if (fSDigits) fSDigits->Clear();
908 }
909
910
911 //____________________________________________________________________
912 TClonesArray*
913 AliFMD::HitsArray() 
914 {
915   // Initialize hit array if not already, and return pointer to it. 
916   if (!fHits) { 
917     fHits = new TClonesArray("AliFMDHit", 1000);
918     fNhits = 0;
919   }
920   return fHits;
921 }
922
923 //____________________________________________________________________
924 TClonesArray*
925 AliFMD::DigitsArray() 
926 {
927   // Initialize digit array if not already, and return pointer to it. 
928   if (!fDigits) { 
929     fDigits = new TClonesArray("AliFMDDigit", 1000);
930     fNdigits = 0;
931   }
932   return fDigits;
933 }
934
935 //____________________________________________________________________
936 TClonesArray*
937 AliFMD::SDigitsArray() 
938 {
939   // Initialize digit array if not already, and return pointer to it. 
940   if (!fSDigits) { 
941     fSDigits = new TClonesArray("AliFMDSDigit", 1000);
942     fNsdigits = 0;
943   }
944   return fSDigits;
945 }
946
947 //====================================================================
948 //
949 // Digitization 
950 //
951 //____________________________________________________________________
952 void 
953 AliFMD::Hits2Digits() 
954 {
955   // Create AliFMDDigit's from AliFMDHit's.  This is done by making a
956   // AliFMDDigitizer, and executing that code.
957   // 
958   AliRunDigitizer* manager = new AliRunDigitizer(1, 1);
959   manager->SetInputStream(0, "galice.root");
960   manager->SetOutputFile("H2Dfile");
961   
962   /* AliDigitizer* dig =*/ CreateDigitizer(manager);
963   manager->Exec("");
964 }
965
966 //____________________________________________________________________
967 void 
968 AliFMD::Hits2SDigits() 
969 {
970   // Create AliFMDSDigit's from AliFMDHit's.  This is done by creating
971   // an AliFMDSDigitizer object, and executing it. 
972   // 
973   AliDigitizer* sdig = new AliFMDSDigitizer("galice.root");
974   sdig->Exec("");
975 }
976
977   
978 //____________________________________________________________________
979 AliDigitizer* 
980 AliFMD::CreateDigitizer(AliRunDigitizer* manager) const
981 {
982   // Create a digitizer object 
983   return new AliFMDDigitizer(manager);
984 }
985
986 //====================================================================
987 //
988 // Raw data simulation 
989 //
990 //__________________________________________________________________
991 void 
992 AliFMD::Digits2Raw() 
993 {
994   // Turn digits into raw data. 
995   // 
996   // Digits are read from the Digit branch, and processed to make
997   // three DDL files, one for each of the sub-detectors FMD1, FMD2,
998   // and FMD3. 
999   //
1000   // The raw data files consists of a header, followed by ALTRO
1001   // formatted blocks.  
1002   // 
1003   //          +-------------+
1004   //          | Header      |
1005   //          +-------------+
1006   //          | ALTRO Block |
1007   //          | ...         |
1008   //          +-------------+
1009   //          DDL file 
1010   // 
1011   // An ALTRO formatted block, in the FMD context, consists of a
1012   // number of counts followed by a trailer. 
1013   // 
1014   //          +------------------+
1015   //          | Count            |
1016   //          | ...              |
1017   //          | possible fillers |
1018   //          +------------------+
1019   //          | Trailer          |
1020   //          +------------------+
1021   //          ALTRO block 
1022   // 
1023   // The counts are listed backwards, that is, starting with the
1024   // latest count, and ending in the first. 
1025   // 
1026   // Each count consist of 1 or more ADC samples of the VA1_ALICE
1027   // pre-amp. signal.  Just how many samples are used depends on
1028   // whether the ALTRO over samples the pre-amp.  Each sample is a
1029   // 10-bit word, and the samples are grouped into 40-bit blocks 
1030   //
1031   //          +------------------------------------+
1032   //          |  S(n)   | S(n-1) | S(n-2) | S(n-3) |
1033   //          |  ...    | ...    | ...    | ...    |
1034   //          |  S(2)   | S(1)   | AA     | AA     |
1035   //          +------------------------------------+
1036   //          Counts + possible filler 
1037   //
1038   // The trailer of the number of words of signales, the starting
1039   // strip number, the sector number, and the ring ID; each 10-bit
1040   // words,  packed into 40-bits. 
1041   // 
1042   //          +------------------------------------+
1043   //          | # words | start  | sector | ring   |
1044   //          +------------------------------------+
1045   //          Trailer
1046   // 
1047   // Note, that this method assumes that the digits are ordered. 
1048   //
1049   AliFMD* fmd = static_cast<AliFMD*>(gAlice->GetDetector(GetName()));
1050   fLoader->LoadDigits();
1051   TTree* digitTree = fLoader->TreeD();
1052   if (!digitTree) {
1053     Error("Digits2Raw", "no digit tree");
1054     return;
1055   }
1056   
1057   TClonesArray* digits = new TClonesArray("AliFMDDigit", 1000);
1058   fmd->SetTreeAddress();
1059   TBranch* digitBranch = digitTree->GetBranch(GetName());
1060   if (!digitBranch) {
1061     Error("Digits2Raw", "no branch for %s", GetName());
1062     return;
1063   }
1064   digitBranch->SetAddress(&digits);
1065   
1066   Int_t nEvents = Int_t(digitTree->GetEntries());
1067   for (Int_t event = 0; event < nEvents; event++) {
1068     fmd->ResetDigits();
1069     digitTree->GetEvent(event);
1070     
1071     Int_t nDigits = digits->GetEntries();
1072     if (nDigits < 1) continue;
1073
1074
1075     UShort_t prevDetector = 0;
1076     Char_t   prevRing     = '\0';
1077     UShort_t prevSector   = 0;
1078     // UShort_t prevStrip    = 0;
1079
1080     // The first seen strip number for a channel 
1081     UShort_t startStrip   = 0;
1082     
1083     // Which channel number in the ALTRO channel we're at 
1084     UShort_t offset       = 0;
1085
1086     // How many times the ALTRO Samples one VA1_ALICE channel 
1087     Int_t sampleRate = 1;
1088
1089     // A buffer to hold 1 ALTRO channel - Normally, one ALTRO channel
1090     // holds 128 VA1_ALICE channels, sampled at a rate of `sampleRate' 
1091     TArrayI channel(128 * sampleRate);
1092     
1093     // The Altro buffer 
1094     AliAltroBuffer* altro = 0;
1095     
1096     // Loop over the digits in the event.  Note, that we assume the
1097     // the digits are in order in the branch.   If they were not, we'd
1098     // have to cache all channels before we could write the data to
1099     // the ALTRO buffer, or we'd have to set up a map of the digits. 
1100     for (Int_t i = 0; i < nDigits; i++) {
1101       // Get the digit
1102       AliFMDDigit* digit = static_cast<AliFMDDigit*>(digits->At(i));
1103
1104       UShort_t det    = digit->Detector();
1105       Char_t   ring   = digit->Ring();
1106       UShort_t sector = digit->Sector();
1107       UShort_t strip  = digit->Strip();
1108       if (det != prevDetector) {
1109         AliDebug(10, Form("FMD: New DDL, was %d, now %d",
1110                           kBaseDDL + prevDetector - 1,
1111                           kBaseDDL + det - 1));
1112         // If an altro exists, delete the object, flushing the data to
1113         // disk, and closing the file. 
1114         if (altro) { 
1115           // When the first argument is false, we write the real
1116           // header. 
1117           AliDebug(10, Form("New altro: Write channel at %d Strip: %d "
1118                             "Sector: %d  Ring: %d", 
1119                             i, startStrip, prevSector, prevRing));
1120           // TPC to FMD translations 
1121           // 
1122           //    TPC                FMD
1123           //    ----------+-----------
1124           //    pad       |      strip
1125           //    row       |     sector
1126           //    sector    |       ring
1127           // 
1128           altro->WriteChannel(Int_t(startStrip), 
1129                               Int_t(prevSector), 
1130                               Int_t((prevRing == 'I' ? 0 : 1)), 
1131                               channel.fN, channel.fArray, 0);
1132           altro->Flush();
1133           altro->WriteDataHeader(kFALSE, kFALSE);
1134           delete altro;
1135           altro = 0;
1136         }
1137
1138         prevDetector = det;
1139         // Need to open a new DDL! 
1140         Int_t ddlId = kBaseDDL + det - 1;
1141         TString filename(Form("%s_%d.ddl", GetName(),  ddlId));
1142
1143         AliDebug(10, Form("New altro buffer with DDL file %s", 
1144                           filename.Data()));
1145         AliDebug(10, Form("New altro at %d", i));
1146         // Create a new altro buffer - a `1' as the second argument
1147         // means `write mode' 
1148         altro = new AliAltroBuffer(filename.Data(), 1);
1149         
1150         // Write a dummy (first argument is true) header to the DDL
1151         // file - later on, when we close the file, we write the real
1152         // header
1153         altro->WriteDataHeader(kTRUE, kFALSE);
1154
1155         // Figure out the sample rate 
1156         if (digit->Count2() > 0) sampleRate = 2;
1157         if (digit->Count3() > 0) sampleRate = 3;
1158
1159         channel.Set(128 * sampleRate);
1160         offset     = 0;
1161         prevRing   = ring;
1162         prevSector = sector;
1163         startStrip = strip;
1164       }
1165       else if (offset == 128                        
1166                || digit->Ring() != prevRing 
1167                || digit->Sector() != prevSector) {
1168         // Force a new Altro channel
1169         AliDebug(10, Form("Flushing channel to disk because %s",
1170                           (offset == 128 ? "channel is full" :
1171                            (ring != prevRing ? "new ring up" :
1172                             "new sector up"))));
1173         AliDebug(10, Form("New Channel: Write channel at %d Strip: %d "
1174                           "Sector: %d  Ring: %d", 
1175                           i, startStrip, prevSector, prevRing));
1176         altro->WriteChannel(Int_t(startStrip), 
1177                             Int_t(prevSector), 
1178                             Int_t((prevRing == 'I' ? 0 : 1)), 
1179                             channel.fN, channel.fArray, 0);
1180         // Reset and update channel variables 
1181         channel.Reset(0);
1182         offset     = 0; 
1183         startStrip = strip;
1184         prevRing   = ring;
1185         prevSector = sector;
1186       }
1187
1188       // Store the counts of the ADC in the channel buffer 
1189       channel[offset * sampleRate] = digit->Count1();
1190       if (sampleRate > 1) 
1191         channel[offset * sampleRate + 1] = digit->Count2();
1192       if (sampleRate > 2) 
1193         channel[offset * sampleRate + 2] = digit->Count3();
1194       offset++;
1195     }
1196     // Finally, we need to close the final ALTRO buffer if it wasn't
1197     // already 
1198     if (altro) {
1199       altro->Flush();
1200       altro->WriteDataHeader(kFALSE, kFALSE);
1201       delete altro;
1202     }
1203   }
1204   fLoader->UnloadDigits();
1205 }
1206
1207 //==================================================================
1208 //
1209 // Various setter functions for the common paramters 
1210 //
1211
1212 //__________________________________________________________________
1213 void 
1214 AliFMD::SetLegLength(Double_t length) 
1215 {
1216   // Set lenght of plastic legs that hold the hybrid (print board and
1217   // silicon sensor) onto the honeycomp support
1218   //
1219   // DebugGuard guard("AliFMD::SetLegLength");
1220   AliDebug(10, "AliFMD::SetLegLength");
1221   fLegLength = length;
1222   fInner->SetLegLength(fLegLength);
1223   fOuter->SetLegLength(fLegLength);
1224 }
1225
1226 //__________________________________________________________________
1227 void 
1228 AliFMD::SetLegOffset(Double_t offset) 
1229 {
1230   // Set offset from edge of hybrid to plastic legs that hold the
1231   // hybrid (print board and silicon sensor) onto the honeycomp
1232   // support 
1233   //
1234   // DebugGuard guard("AliFMD::SetLegOffset");
1235   AliDebug(10, "AliFMD::SetLegOffset");
1236   fInner->SetLegOffset(offset);
1237   fOuter->SetLegOffset(offset);
1238 }
1239
1240 //__________________________________________________________________
1241 void 
1242 AliFMD::SetLegRadius(Double_t radius) 
1243 {
1244   // Set the diameter of the plastic legs that hold the hybrid (print
1245   // board and silicon sensor) onto the honeycomp support
1246   //
1247   // DebugGuard guard("AliFMD::SetLegRadius");
1248   AliDebug(10, "AliFMD::SetLegRadius");
1249   fLegRadius = radius;
1250   fInner->SetLegRadius(fLegRadius);
1251   fOuter->SetLegRadius(fLegRadius);
1252 }
1253
1254 //__________________________________________________________________
1255 void 
1256 AliFMD::SetModuleSpacing(Double_t spacing) 
1257 {
1258   // Set the distance between the front and back sensor modules
1259   // (module staggering). 
1260   //
1261   // DebugGuard guard("AliFMD::SetModuleSpacing");
1262   AliDebug(10, "AliFMD::SetModuleSpacing");  
1263   fModuleSpacing = spacing;
1264   fInner->SetModuleSpacing(fModuleSpacing);
1265   fOuter->SetModuleSpacing(fModuleSpacing);
1266 }
1267
1268 //====================================================================
1269 //
1270 // Utility 
1271 //
1272 //__________________________________________________________________
1273 void 
1274 AliFMD::Browse(TBrowser* b) 
1275 {
1276   // Browse this object. 
1277   //
1278   AliDebug(10, "AliFMD::Browse");
1279   AliDetector::Browse(b);
1280   if (fInner) b->Add(fInner, "Inner Ring");
1281   if (fOuter) b->Add(fOuter, "Outer Ring");
1282   if (fFMD1)  b->Add(fFMD1,  "FMD1 SubDetector");
1283   if (fFMD2)  b->Add(fFMD2,  "FMD2 SubDetector");
1284   if (fFMD3)  b->Add(fFMD3,  "FMD3 SubDetector");
1285 }
1286
1287
1288 //___________________________________________________________________
1289 //
1290 // EOF
1291 //