Added the class AliFMDGeometryBuilder (and derived
[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 3 sub-detectors FMD1, FMD2, and FMD3, each of
23 // which has 1 or 2 rings of silicon sensors. 
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 simulation
30 //
31 //
32 //       +----------+   +----------+   
33 //       | AliFMDv1 |   | AliFMDv0 |   
34 //       +----------+   +----------+   
35 //            |              |                    +-----------------+
36 //       +----+--------------+                 +--| AliFMDDigitizer |
37 //       |                                     |  +-----------------+
38 //       |           +---------------------+   |
39 //       |        +--| AliFMDBaseDigitizer |<--+
40 //       V     1  |  +---------------------+   |
41 //  +--------+<>--+                            |  +------------------+
42 //  | AliFMD |                                 +--| AliFMDSDigitizer |    
43 //  +--------+<>--+                               +------------------+       
44 //             1  |  +-----------------+ 
45 //                +--| AliFMDSimulator |
46 //                   +-----------------+
47 //                            ^              
48 //                            |
49 //              +-------------+-------------+
50 //              |                           |         
51 //     +--------------------+   +-------------------+
52 //     | AliFMDGeoSimulator |   | AliFMDG3Simulator | 
53 //     +--------------------+   +-------------------+
54 //               ^                         ^
55 //               |                         |
56 //  +-----------------------+   +----------------------+
57 //  | AliFMDGeoOldSimulator |   | AliFMDG3OldSimulator |
58 //  +-----------------------+   +----------------------+
59 //      
60 //
61 // *  AliFMD 
62 //    This defines the interface for the various parts of AliROOT that
63 //    uses the FMD, like AliFMDSimulator, AliFMDDigitizer, 
64 //    AliFMDReconstructor, and so on. 
65 //
66 // *  AliFMDv0
67 //    This is a concrete implementation of the AliFMD interface. 
68 //    It is the responsibility of this class to create the FMD
69 //    geometry.
70 //
71 // *  AliFMDv1 
72 //    This is a concrete implementation of the AliFMD interface. 
73 //    It is the responsibility of this class to create the FMD
74 //    geometry, process hits in the FMD, and serve hits and digits to
75 //    the various clients. 
76 //  
77 // *  AliFMDSimulator
78 //    This is the base class for the FMD simulation tasks.   The
79 //    simulator tasks are responsible to implment the geoemtry, and
80 //    process hits. 
81 //                                                                          
82 // *  AliFMDGeoSimulator
83 //    This is a concrete implementation of the AliFMDSimulator that
84 //    uses the TGeo classes directly only. 
85 //
86 // *  AliFMDG3Simulator
87 //    This is a concrete implementation of the AliFMDSimulator that
88 //    uses the TVirtualMC interface with GEANT 3.21-like messages.
89 //
90
91 // These files are not in the same directory, so there's no reason to
92 // ask the preprocessor to search in the current directory for these
93 // files by including them with `#include "..."' 
94 #include <math.h>               // __CMATH__
95 #include <TClonesArray.h>       // ROOT_TClonesArray
96 #include <TGeometry.h>          // ROOT_TGeomtry
97 #include <TNode.h>              // ROOT_TNode
98 #include <TXTRU.h>              // ROOT_TXTRU
99 #include <TRotMatrix.h>         // ROOT_TRotMatrix
100 #include <TTUBE.h>              // ROOT_TTUBE
101 #include <TTree.h>              // ROOT_TTree
102 #include <TBrowser.h>           // ROOT_TBrowser
103 #include <TMath.h>              // ROOT_TMath
104 #include <TVirtualMC.h>         // ROOT_TVirtualMC
105
106 #include <AliRunDigitizer.h>    // ALIRUNDIGITIZER_H
107 #include <AliLoader.h>          // ALILOADER_H
108 #include <AliRun.h>             // ALIRUN_H
109 #include <AliMC.h>              // ALIMC_H
110 #include "AliMagF.h"            // ALIMAGF_H
111 #include <AliLog.h>             // ALILOG_H
112 #include "AliFMD.h"             // ALIFMD_H
113 #include "AliFMDDigit.h"        // ALIFMDDIGIG_H
114 #include "AliFMDHit.h"          // ALIFMDHIT_H
115 #include "AliFMDGeometry.h"     // ALIFMDGEOMETRY_H
116 #include "AliFMDDetector.h"     // ALIFMDDETECTOR_H
117 #include "AliFMDRing.h"         // ALIFMDRING_H
118 #include "AliFMDDigitizer.h"    // ALIFMDDIGITIZER_H
119 #ifdef USE_PRE_MOVE
120 #include "AliFMDSimulator.h"    // ALIFMDSIMULATOR_H
121 #include "AliFMDG3Simulator.h"  // ALIFMDG3SIMULATOR_H
122 #include "AliFMDGeoSimulator.h" // ALIFMDGEOSIMULATOR_H
123 #include "AliFMDG3OldSimulator.h"       // ALIFMDG3OLDSIMULATOR_H
124 #include "AliFMDGeoOldSimulator.h"      // ALIFMDGEOOLDSIMULATOR_H
125 #else
126 #include "AliFMDGeometryBuilderSimple.h"
127 #endif
128 #include "AliFMDRawWriter.h"    // ALIFMDRAWWRITER_H
129 #include <TVector2.h>
130
131 //____________________________________________________________________
132 ClassImp(AliFMD)
133 #if 0
134   ; // This is to keep Emacs from indenting the next line 
135 #endif 
136
137 //____________________________________________________________________
138 AliFMD::AliFMD()
139   : AliDetector(),
140     fSDigits(0), 
141     fNsdigits(0),
142     fDetailed(kTRUE),
143 #ifdef USE_PRE_MOVE
144     fSimulator(0), 
145 #endif
146     fBad(0)
147 {
148   //
149   // Default constructor for class AliFMD
150   //
151   AliDebug(10, "\tDefault CTOR");
152   fHits        = 0;
153   fDigits      = 0;
154   fIshunt      = 0;
155   fUseOld      = kFALSE;
156   fUseAssembly = kTRUE;
157   fBad         = new TClonesArray("AliFMDHit");
158 }
159
160 //____________________________________________________________________
161 AliFMD::AliFMD(const AliFMD& other)
162   : AliDetector(other),
163     fSDigits(other.fSDigits), 
164     fNsdigits(other.fNsdigits),
165     fDetailed(other.fDetailed),
166 #ifdef USE_PRE_MOVE
167     fSimulator(other.fSimulator),
168 #endif
169     fBad(other.fBad)
170 {
171   // Copy constructor 
172   fUseOld      = other.fUseOld;
173   fUseAssembly = other.fUseAssembly;
174 }
175
176 //____________________________________________________________________
177 AliFMD::AliFMD(const char *name, const char *title)
178   : AliDetector (name, title),
179     fSDigits(0),
180     fNsdigits(0),
181     fDetailed(kTRUE),
182 #ifdef USE_PRE_MOVE
183     fSimulator(0), 
184 #endif
185     fBad(0)
186 {
187   //
188   // Standard constructor for Forward Multiplicity Detector
189   //
190   AliDebug(10, "\tStandard CTOR");
191   fUseOld      = kFALSE;
192   fUseAssembly = kFALSE;
193   fBad         = new TClonesArray("AliFMDHit");
194   
195   // Initialise Hit array
196   HitsArray();
197   gAlice->GetMCApp()->AddHitList(fHits);
198
199   // (S)Digits for the detectors disk
200   DigitsArray();
201   SDigitsArray();
202   
203   // CHC: What is this?
204   fIshunt = 0;
205   SetMarkerColor(kRed);
206   SetLineColor(kYellow);
207 }
208
209 //____________________________________________________________________
210 AliFMD::~AliFMD ()
211 {
212   // Destructor for base class AliFMD
213   if (fHits) {
214     fHits->Delete();
215     delete fHits;
216     fHits = 0;
217   }
218   if (fDigits) {
219     fDigits->Delete();
220     delete fDigits;
221     fDigits = 0;
222   }
223   if (fSDigits) {
224     fSDigits->Delete();
225     delete fSDigits;
226     fSDigits = 0;
227   }
228   if (fBad) {
229     fBad->Delete();
230     delete fBad;
231     fBad = 0;
232   }
233 }
234
235 //____________________________________________________________________
236 AliFMD&
237 AliFMD::operator=(const AliFMD& other)
238 {
239   AliDetector::operator=(other);
240   fSDigits              = other.fSDigits; 
241   fNsdigits             = other.fNsdigits;
242   fDetailed             = other.fDetailed;
243 #ifdef USE_PRE_MOVE
244   fSimulator            = other.fSimulator;
245 #endif
246   fBad                  = other.fBad;
247   return *this;
248 }
249
250 //====================================================================
251 //
252 // GEometry ANd Traking
253 //
254 //____________________________________________________________________
255 void 
256 AliFMD::CreateGeometry()
257 {
258   //
259   // Create the geometry of Forward Multiplicity Detector.  The actual
260   // construction of the geometry is delegated to the class AliFMDRing
261   // and AliFMDSubDetector and the relevant derived classes. 
262   //
263   // The flow of this member function is:
264   //
265   //   FOR rings fInner and fOuter DO  
266   //     AliFMDRing::Init();
267   //   END FOR
268   // 
269   //   Set up hybrud card support (leg) volume shapes  
270   // 
271   //   FOR rings fInner and fOuter DO  
272   //     AliFMDRing::SetupGeometry();
273   //   END FOR
274   // 
275   //   FOR subdetectors fFMD1, fFMD2, and fFMD3 DO 
276   //     AliFMDSubDetector::SetupGeomtry();
277   //   END FOR
278   // 
279   //   FOR subdetectors fFMD1, fFMD2, and fFMD3 DO 
280   //     AliFMDSubDetector::Geomtry();
281   //   END FOR
282   //
283 #ifndef USE_PRE_MOVE
284   AliFMDGeometry*  fmd = AliFMDGeometry::Instance();
285   if (fUseOld) fmd->SetBuilder(new AliFMDGeometryBuilderSimple(fDetailed));
286   fmd->SetDetailed(fDetailed);
287   fmd->UseAssembly(fUseAssembly);
288   fmd->Build();
289 #else
290   if (!fSimulator) {
291     AliFatal("Simulator object not made yet!");
292     return;
293   }
294   fSimulator->DefineGeometry();
295 #endif
296 }    
297
298 //____________________________________________________________________
299 void AliFMD::CreateMaterials() 
300 {
301   // Define the materials and tracking mediums needed by the FMD
302   // simulation.   These mediums are made by sending the messages
303   // AliMaterial, AliMixture, and AliMedium to the passed AliModule
304   // object module.   The defined mediums are 
305   // 
306   //    FMD Si$         Silicon (active medium in sensors)
307   //    FMD C$          Carbon fibre (support cone for FMD3 and vacuum pipe)
308   //    FMD Al$         Aluminium (honeycomb support plates)
309   //    FMD PCB$        Printed Circuit Board (FEE board with VA1_3)
310   //    FMD Chip$       Electronics chips (currently not used)
311   //    FMD Air$        Air (Air in the FMD)
312   //    FMD Plastic$    Plastic (Support legs for the hybrid cards)
313   //
314   // Pointers to TGeoMedium objects are retrived from the TGeoManager
315   // singleton.  These pointers are later used when setting up the
316   // geometry 
317   AliDebug(10, "\tCreating materials");
318   // Get pointer to geometry singleton object. 
319   AliFMDGeometry* geometry = AliFMDGeometry::Instance();
320   geometry->Init();
321 #if 0
322   if (gGeoManager && gGeoManager->GetMedium("FMD Si$")) {
323     // We need to figure out the some stuff about the geometry
324     fmd->ExtractGeomInfo();
325     return;
326   }
327 #endif  
328 #ifndef USE_PRE_MOVE     
329   Int_t    id;
330   Double_t a                = 0;
331   Double_t z                = 0;
332   Double_t density          = 0;
333   Double_t radiationLength  = 0;
334   Double_t absorbtionLength = 999;
335   Int_t    fieldType        = gAlice->Field()->Integ();     // Field type 
336   Double_t maxField         = gAlice->Field()->Max();     // Field max.
337   Double_t maxBending       = 0;     // Max Angle
338   Double_t maxStepSize      = 0.001; // Max step size 
339   Double_t maxEnergyLoss    = 1;     // Max Delta E
340   Double_t precision        = 0.001; // Precision
341   Double_t minStepSize      = 0.001; // Minimum step size 
342  
343   // Silicon 
344   a                = 28.0855;
345   z                = 14.;
346   density          = geometry->GetSiDensity();
347   radiationLength  = 9.36;
348   maxBending       = 1;
349   maxStepSize      = .001;
350   precision        = .001;
351   minStepSize      = .001;
352   id               = kSiId;
353   AliMaterial(id, "Si$", a, z, density, radiationLength, absorbtionLength);
354   AliMedium(kSiId, "Si$", id,1,fieldType,maxField,maxBending,
355             maxStepSize,maxEnergyLoss,precision,minStepSize);
356   
357
358   // Carbon 
359   a                = 12.011;
360   z                = 6.;
361   density          = 2.265;
362   radiationLength  = 18.8;
363   maxBending       = 10;
364   maxStepSize      = .01;
365   precision        = .003;
366   minStepSize      = .003;
367   id               = kCarbonId;
368   AliMaterial(id, "Carbon$", a, z, density, radiationLength, absorbtionLength);
369   AliMedium(kCarbonId, "Carbon$", id,0,fieldType,maxField,maxBending,
370                     maxStepSize,maxEnergyLoss,precision,minStepSize);
371
372   // Aluminum
373   a                = 26.981539;
374   z                = 13.;
375   density          = 2.7;
376   radiationLength  = 8.9;
377   id               = kAlId;
378   AliMaterial(id, "Aluminum$",a,z, density, radiationLength, absorbtionLength);
379   AliMedium(kAlId, "Aluminum$", id, 0, fieldType, maxField, maxBending,
380             maxStepSize, maxEnergyLoss, precision, minStepSize);
381   
382   
383   // Copper 
384   a                = 63.546;
385   z                = 29;
386   density          =  8.96;
387   radiationLength  =  1.43;
388   id               = kCopperId;
389   AliMaterial(id, "Copper$", 
390                       a, z, density, radiationLength, absorbtionLength);
391   AliMedium(kCopperId, "Copper$", id, 0, fieldType, maxField, maxBending,
392             maxStepSize, maxEnergyLoss, precision, minStepSize);
393   
394
395   // Silicon chip 
396   {
397     Float_t as[] = { 12.0107,      14.0067,      15.9994,
398                       1.00794,     28.0855,     107.8682 };
399     Float_t zs[] = {  6.,           7.,           8.,
400                       1.,          14.,          47. };
401     Float_t ws[] = {  0.039730642,  0.001396798,  0.01169634,
402                       0.004367771,  0.844665,     0.09814344903 };
403     density          = 2.36436;
404     maxBending       = 10;
405     maxStepSize      = .01;
406     precision        = .003;
407     minStepSize      = .003;
408     id               = kSiChipId;
409     AliMixture(id, "Si Chip$", as, zs, density, 6, ws);
410     AliMedium(kSiChipId, "Si Chip$",  id, 0, fieldType, maxField, maxBending, 
411               maxStepSize, maxEnergyLoss, precision, minStepSize);
412   }
413   
414   // Kaption
415   {
416     Float_t as[] = { 1.00794,  12.0107,  14.010,   15.9994};
417     Float_t zs[] = { 1.,        6.,       7.,       8.};
418     Float_t ws[] = { 0.026362,  0.69113,  0.07327,  0.209235};
419     density          = 1.42;
420     maxBending       = 1;
421     maxStepSize      = .001;
422     precision        = .001;
423     minStepSize      = .001;
424     id               = kKaptonId;
425     AliMixture(id, "Kaption$", as, zs, density, 4, ws);
426     AliMedium(kKaptonId, "Kaption$", id,0,fieldType,maxField,maxBending,
427               maxStepSize,maxEnergyLoss,precision,minStepSize);
428   }
429
430   // Air
431   {
432     Float_t as[] = { 12.0107, 14.0067,   15.9994,  39.948 };
433     Float_t zs[] = {  6.,      7.,       8.,       18. };
434     Float_t ws[] = { 0.000124, 0.755267, 0.231781, 0.012827 }; 
435     density      = .00120479;
436     maxBending   = 1;
437     maxStepSize  = .001;
438     precision    = .001;
439     minStepSize  = .001;
440     id           = kAirId;
441     AliMixture(id, "Air$", as, zs, density, 4, ws);
442     AliMedium(kAirId, "Air$", id,0,fieldType,maxField,maxBending,
443               maxStepSize,maxEnergyLoss,precision,minStepSize);
444   }
445   
446   // PCB
447   {
448     Float_t zs[] = { 14.,         20.,         13.,         12.,
449                       5.,         22.,         11.,         19.,
450                      26.,          9.,          8.,          6.,
451                       7.,          1.};
452     Float_t as[] = { 28.0855,     40.078,      26.981538,   24.305, 
453                      10.811,      47.867,      22.98977,    39.0983,
454                      55.845,      18.9984,     15.9994,     12.0107,
455                      14.0067,      1.00794};
456     Float_t ws[] = {  0.15144894,  0.08147477,  0.04128158,  0.00904554, 
457                       0.01397570,  0.00287685,  0.00445114,  0.00498089,
458                       0.00209828,  0.00420000,  0.36043788,  0.27529426,
459                       0.01415852,  0.03427566};
460     density      = 1.8;
461     maxBending   = 1;
462     maxStepSize  = .001;
463     precision    = .001;
464     minStepSize  = .001;
465     id           = kPcbId;
466     AliMixture(id, "PCB$", as, zs, density, 14, ws);
467     AliMedium(kPcbId, "PCB$", id,0,fieldType,maxField,maxBending,
468               maxStepSize,maxEnergyLoss,precision,minStepSize);
469   }
470   
471   // Plastic 
472   {
473     Float_t as[] = { 1.01, 12.01 };
474     Float_t zs[] = { 1.,   6.    };
475     Float_t ws[] = { 1.,   1.    };
476     density      = 1.03;
477     maxBending   = 10;
478     maxStepSize  = .01;
479     precision    = .003;
480     minStepSize  = .003;
481     id           = kPlasticId;
482     AliMixture(id, "Plastic$", as, zs, density, -2, ws);
483     AliMedium(kPlasticId, "Plastic$", id,0,fieldType,maxField,maxBending,
484               maxStepSize,maxEnergyLoss,precision,minStepSize);
485   }
486 #else
487   AliDebug(10, "\tCreating materials");
488
489   if (fSimulator) {
490     AliFatal("Simulator object already instantised!");
491     return;
492   }
493   TVirtualMC* mc = TVirtualMC::GetMC();
494
495   Bool_t geo = mc->IsRootGeometrySupported();
496   if (geo) {
497     if (fUseOld) 
498       fSimulator = new AliFMDGeoOldSimulator(this, fDetailed);
499     else 
500       fSimulator = new AliFMDGeoSimulator(this, fDetailed);
501   }
502   else {
503     if (fUseOld) 
504       fSimulator = new AliFMDG3OldSimulator(this, fDetailed);
505     else    
506       fSimulator = new AliFMDG3Simulator(this, fDetailed);
507   }
508   AliDebug(1, Form("using a %s as simulation backend", 
509                    fSimulator->IsA()->GetName()));
510   fSimulator->SetDetailed(fDetailed);
511   fSimulator->UseAssembly(fUseAssembly);
512   fSimulator->DefineMaterials();
513 #endif
514 }
515
516 //____________________________________________________________________
517 void  
518 AliFMD::Init()
519 {}
520
521 //____________________________________________________________________
522 void
523 AliFMD::FinishEvent()
524 {
525 #ifndef USE_PRE_MOVE
526   if (fBad && fBad->GetEntries() > 0) {
527     AliWarning((Form("EndEvent", "got %d 'bad' hits", fBad->GetEntries())));
528     TIter next(fBad);
529     AliFMDHit* hit;
530     while ((hit = static_cast<AliFMDHit*>(next()))) 
531       hit->Print("D");
532     fBad->Clear();
533   }
534 #else
535   if (fSimulator) fSimulator->EndEvent();
536 #endif
537 }
538
539
540 //====================================================================
541 //
542 // Graphics and event display
543 //
544 //____________________________________________________________________
545 void 
546 AliFMD::BuildGeometry()
547 {
548   //
549   // Build simple ROOT TNode geometry for event display
550   //
551   // Build a simplified geometry of the FMD used for event display  
552   // 
553   // The actual building of the TNodes is done by
554   // AliFMDSubDetector::SimpleGeometry. 
555   AliDebug(10, "\tCreating a simplified geometry");
556
557   AliFMDGeometry* fmd = AliFMDGeometry::Instance();
558   
559   static TXTRU*     innerShape = 0;
560   static TXTRU*     outerShape = 0;
561   static TObjArray* innerRot   = 0;
562   static TObjArray* outerRot   = 0;
563
564   if (!innerShape || !outerShape) {
565     // Make the shapes for the modules 
566     for (Int_t i = 0; i < 2; i++) {
567       AliFMDRing* r = 0;
568       switch (i) {
569       case 0: r = fmd->GetRing('I'); break;
570       case 1: r = fmd->GetRing('O'); break;
571       }
572       if (!r) {
573         AliError(Form("no ring found for i=%d", i));
574         return;
575       }
576       Double_t    siThick  = r->GetSiThickness();
577       const Int_t nv       = r->GetNVerticies();
578       Double_t    theta    = r->GetTheta();
579       Int_t       nmod     = r->GetNModules();
580       
581       TXTRU* shape = new TXTRU(r->GetName(), r->GetTitle(), "void", nv, 2);
582       for (Int_t j = 0; j < nv; j++) {
583         TVector2* vv = r->GetVertex(nv - 1 - j);
584         shape->DefineVertex(j, vv->X(), vv->Y());
585       }
586       shape->DefineSection(0, -siThick / 2, 1, 0, 0);
587       shape->DefineSection(1, +siThick / 2, 1, 0, 0);
588       shape->SetLineColor(GetLineColor());
589       
590       TObjArray* rots = new TObjArray(nmod);
591       for (Int_t j = 0; j < nmod; j++) {
592         Double_t th = (j + .5) * theta * 2;
593         TString name(Form("FMD_ring_%c_rot_%02d", r->GetId(), j));
594         TString title(Form("FMD Ring %c Rotation # %d", r->GetId(), j));
595         TRotMatrix* rot = new TRotMatrix(name.Data(), title.Data(),
596                                          90, th, 90, fmod(90+th,360), 0, 0);
597         rots->AddAt(rot, j);
598       }
599       
600       switch (r->GetId()) {
601       case 'i':
602       case 'I': innerShape = shape; innerRot = rots; break;
603       case 'o':
604       case 'O': outerShape = shape; outerRot = rots; break;
605       }
606     }
607   }
608   
609   TNode* top = gAlice->GetGeometry()->GetNode("alice");
610   
611   for (Int_t i = 1; i <= 3; i++) {
612     AliFMDDetector* det = fmd->GetDetector(i);
613     if (!det) {
614       Warning("BuildGeometry", "FMD%d seems to be disabled", i);
615       continue;
616     }
617     Double_t w  = 0;
618     Double_t rh = det->GetRing('I')->GetHighR();
619     Char_t   id = 'I';
620     if (det->GetRing('O')) {
621       w  = TMath::Abs(det->GetRingZ('O') - det->GetRingZ('I'));
622       id = (TMath::Abs(det->GetRingZ('O')) 
623             > TMath::Abs(det->GetRingZ('I')) ? 'O' : 'I');
624       rh = det->GetRing('O')->GetHighR();
625     }
626     w += (det->GetRing(id)->GetModuleSpacing() +
627           det->GetRing(id)->GetSiThickness());
628     TShape* shape = new TTUBE(det->GetName(), det->GetTitle(), "void",
629                               det->GetRing('I')->GetLowR(), rh, w / 2);
630     Double_t z = (det->GetRingZ('I') - w / 2);
631     if (z > 0) z += det->GetRing(id)->GetModuleSpacing();
632     top->cd();
633     TNode* node = new TNode(det->GetName(), det->GetTitle(), shape, 
634                             0, 0, z, 0);
635     fNodes->Add(node);
636     
637     for (Int_t j = 0; j < 2; j++) {
638       AliFMDRing* r      = 0;
639       TShape*     rshape = 0;
640       TObjArray*  rots   = 0;
641       switch (j) {
642       case 0: 
643         r = det->GetRing('I'); rshape = innerShape; rots = innerRot; break;
644       case 1: 
645         r = det->GetRing('O'); rshape = outerShape; rots = outerRot; break;
646       }
647       if (!r) continue;
648       
649       Double_t    siThick  = r->GetSiThickness();
650       Int_t       nmod     = r->GetNModules();
651       Double_t    modspace = r->GetModuleSpacing();
652       Double_t    rz       = - (z - det->GetRingZ(r->GetId()));
653       
654       for (Int_t k = 0; k < nmod; k++) {
655         node->cd();
656         Double_t    offz    = (k % 2 == 1 ? modspace : 0);
657         TRotMatrix* rot     = static_cast<TRotMatrix*>(rots->At(k));
658         TString name(Form("%s%c_module_%02d", det->GetName(), r->GetId(),k));
659         TString title(Form("%s%c Module %d", det->GetName(), r->GetId(),k));
660         TNode* mnod = new TNode(name.Data(), title.Data(), rshape, 
661                                 0, 0, rz - siThick / 2 
662                                 + TMath::Sign(offz,z), rot);
663         mnod->SetLineColor(GetLineColor());
664         fNodes->Add(mnod);
665       } // for (Int_t k = 0 ; ...)
666     } // for (Int_t j = 0 ; ...)
667   } // for (Int_t i = 1 ; ...)
668 }
669
670 //____________________________________________________________________
671 void 
672 AliFMD::DrawDetector()
673 {
674   //
675   // Draw a shaded view of the Forward multiplicity detector
676   //
677   // DebugGuard guard("AliFMD::DrawDetector");
678   AliDebug(10, "\tDraw detector");
679   
680 #if 0
681   //Set ALIC mother transparent
682   gMC->Gsatt("ALIC","SEEN",0);
683   //
684   gMC->Gdopt("hide", "on");
685   gMC->Gdopt("shad", "on");
686   gMC->Gsatt("*", "fill", 7);
687   gMC->SetClipBox(".");
688   gMC->SetClipBox("*", 0, 1000, -1000, 1000, -1000, 1000);
689   gMC->DefaultRange();
690   gMC->Gdraw("alic", 40, 30, 0, 12, 12, .055, .055);
691   gMC->Gdhead(1111, "Forward Multiplicity Detector");
692   gMC->Gdman(16, 10, "MAN");
693   gMC->Gdopt("hide", "off");
694 #endif
695 }
696
697 //____________________________________________________________________
698 Int_t 
699 AliFMD::DistanceToPrimitive(Int_t, Int_t)
700 {
701   //
702   // Calculate the distance from the mouse to the FMD on the screen
703   // Dummy routine
704   //
705   return 9999;
706 }
707
708 //====================================================================
709 //
710 // Hit and Digit managment 
711 //
712 //____________________________________________________________________
713 void 
714 AliFMD::MakeBranch(Option_t * option)
715 {
716   // Create Tree branches for the FMD.
717   //
718   // Options:
719   //
720   //    H          Make a branch of TClonesArray of AliFMDHit's
721   //    D          Make a branch of TClonesArray of AliFMDDigit's
722   //    S          Make a branch of TClonesArray of AliFMDSDigit's
723   // 
724   const Int_t kBufferSize = 16000;
725   TString branchname(GetName());
726   TString opt(option);
727   
728   if (opt.Contains("H", TString::kIgnoreCase)) {
729     HitsArray();
730     AliDetector::MakeBranch(option); 
731   }
732   if (opt.Contains("D", TString::kIgnoreCase)) { 
733     DigitsArray();
734     MakeBranchInTree(fLoader->TreeD(), branchname.Data(),
735                      &fDigits, kBufferSize, 0);
736   }
737   if (opt.Contains("S", TString::kIgnoreCase)) { 
738     SDigitsArray();
739     MakeBranchInTree(fLoader->TreeS(), branchname.Data(),
740                      &fSDigits, kBufferSize, 0);
741   }
742 }
743
744 //____________________________________________________________________
745 void 
746 AliFMD::SetTreeAddress()
747 {
748   // Set branch address for the Hits, Digits, and SDigits Tree.
749   if (fLoader->TreeH()) HitsArray();
750   AliDetector::SetTreeAddress();
751
752   TTree *treeD = fLoader->TreeD();
753   if (treeD) {
754     DigitsArray();
755     TBranch* branch = treeD->GetBranch ("FMD");
756     if (branch) branch->SetAddress(&fDigits);
757   }
758
759   TTree *treeS = fLoader->TreeS();
760   if (treeS) {
761     SDigitsArray();
762     TBranch* branch = treeS->GetBranch ("FMD");
763     if (branch) branch->SetAddress(&fSDigits);
764   }
765 }
766
767
768
769 //____________________________________________________________________
770 void 
771 AliFMD::SetHitsAddressBranch(TBranch *b)
772 {
773   // Set the TClonesArray to read hits into. 
774   b->SetAddress(&fHits);
775 }
776
777 //____________________________________________________________________
778 void 
779 AliFMD::AddHit(Int_t track, Int_t *vol, Float_t *hits) 
780 {
781   // Add a hit to the hits tree 
782   // 
783   // The information of the two arrays are decoded as 
784   // 
785   // Parameters
786   //    track                Track #
787   //    ivol[0]  [UShort_t ] Detector # 
788   //    ivol[1]  [Char_t   ] Ring ID 
789   //    ivol[2]  [UShort_t ] Sector #
790   //    ivol[3]  [UShort_t ] Strip # 
791   //    hits[0]  [Float_t  ] Track's X-coordinate at hit 
792   //    hits[1]  [Float_t  ] Track's Y-coordinate at hit
793   //    hits[3]  [Float_t  ] Track's Z-coordinate at hit
794   //    hits[4]  [Float_t  ] X-component of track's momentum             
795   //    hits[5]  [Float_t  ] Y-component of track's momentum             
796   //    hits[6]  [Float_t  ] Z-component of track's momentum            
797   //    hits[7]  [Float_t  ] Energy deposited by track                  
798   //    hits[8]  [Int_t    ] Track's particle Id # 
799   //    hits[9]  [Float_t  ] Time when the track hit
800   // 
801   // 
802   AddHitByFields(track, 
803                  UShort_t(vol[0]),  // Detector # 
804                  Char_t(vol[1]),    // Ring ID
805                  UShort_t(vol[2]),  // Sector # 
806                  UShort_t(vol[3]),  // Strip # 
807                  hits[0],           // X
808                  hits[1],           // Y
809                  hits[2],           // Z
810                  hits[3],           // Px
811                  hits[4],           // Py
812                  hits[5],           // Pz
813                  hits[6],           // Energy loss 
814                  Int_t(hits[7]),    // PDG 
815                  hits[8]);          // Time
816 }
817
818 //____________________________________________________________________
819 AliFMDHit*
820 AliFMD::AddHitByFields(Int_t    track, 
821                        UShort_t detector, 
822                        Char_t   ring, 
823                        UShort_t sector, 
824                        UShort_t strip, 
825                        Float_t  x, 
826                        Float_t  y, 
827                        Float_t  z,
828                        Float_t  px, 
829                        Float_t  py, 
830                        Float_t  pz,
831                        Float_t  edep,
832                        Int_t    pdg,
833                        Float_t  t)
834 {
835   //
836   // Add a hit to the list
837   //
838   // Parameters:
839   // 
840   //    track     Track #
841   //    detector  Detector # (1, 2, or 3)                      
842   //    ring      Ring ID ('I' or 'O')
843   //    sector    Sector # (For inner/outer rings: 0-19/0-39)
844   //    strip     Strip # (For inner/outer rings: 0-511/0-255)
845   //    x         Track's X-coordinate at hit
846   //    y         Track's Y-coordinate at hit
847   //    z         Track's Z-coordinate at hit
848   //    px        X-component of track's momentum 
849   //    py        Y-component of track's momentum
850   //    pz        Z-component of track's momentum
851   //    edep      Energy deposited by track
852   //    pdg       Track's particle Id #
853   //    t         Time when the track hit 
854   // 
855   TClonesArray& a = *(HitsArray());
856   // Search through the list of already registered hits, and see if we
857   // find a hit with the same parameters.  If we do, then don't create
858   // a new hit, but rather update the energy deposited in the hit.
859   // This is done, so that a FLUKA based simulation will get the
860   // number of hits right, not just the enerrgy deposition. 
861   AliFMDHit* hit = 0;
862   for (Int_t i = 0; i < fNhits; i++) {
863     if (!a.At(i)) continue;
864     hit = static_cast<AliFMDHit*>(a.At(i));
865     if (hit->Detector() == detector 
866         && hit->Ring() == ring
867         && hit->Sector() == sector 
868         && hit->Strip() == strip
869         && hit->Track() == track) {
870       Warning("AddHit", "already had a hit in FMD%d%c[%2d,%3d] for track # %d,"
871               " adding energy (%f) to that hit (%f) -> %f", 
872               detector, ring, sector, strip, track, edep, hit->Edep(),
873               hit->Edep() + edep);
874       hit->SetEdep(hit->Edep() + edep);
875       return hit;
876     }
877   }
878   // If hit wasn't already registered, do so know. 
879   hit = new (a[fNhits]) AliFMDHit(fIshunt, track, detector, ring, sector, 
880                                   strip, x, y, z, px, py, pz, edep, pdg, t);
881   fNhits++;
882   return hit;
883 }
884
885 //____________________________________________________________________
886 void 
887 AliFMD::AddDigit(Int_t* digits, Int_t*)
888 {
889   // Add a digit to the Digit tree 
890   // 
891   // Paramters 
892   //
893   //    digits[0]  [UShort_t] Detector #
894   //    digits[1]  [Char_t]   Ring ID
895   //    digits[2]  [UShort_t] Sector #
896   //    digits[3]  [UShort_t] Strip #
897   //    digits[4]  [UShort_t] ADC Count 
898   //    digits[5]  [Short_t]  ADC Count, -1 if not used
899   //    digits[6]  [Short_t]  ADC Count, -1 if not used 
900   // 
901   AddDigitByFields(UShort_t(digits[0]),  // Detector #
902                    Char_t(digits[1]),    // Ring ID
903                    UShort_t(digits[2]),  // Sector #
904                    UShort_t(digits[3]),  // Strip #
905                    UShort_t(digits[4]),  // ADC Count1 
906                    Short_t(digits[5]),   // ADC Count2 
907                    Short_t(digits[6]));  // ADC Count3 
908 }
909
910 //____________________________________________________________________
911 void 
912 AliFMD::AddDigitByFields(UShort_t detector, 
913                          Char_t   ring, 
914                          UShort_t sector, 
915                          UShort_t strip, 
916                          UShort_t count1, 
917                          Short_t  count2,
918                          Short_t  count3)
919 {
920   // add a real digit - as coming from data
921   // 
922   // Parameters 
923   //
924   //    detector  Detector # (1, 2, or 3)                      
925   //    ring      Ring ID ('I' or 'O')
926   //    sector    Sector # (For inner/outer rings: 0-19/0-39)
927   //    strip     Strip # (For inner/outer rings: 0-511/0-255)
928   //    count1    ADC count (a 10-bit word)
929   //    count2    ADC count (a 10-bit word), or -1 if not used
930   //    count3    ADC count (a 10-bit word), or -1 if not used
931   TClonesArray& a = *(DigitsArray());
932   
933   new (a[fNdigits++]) 
934     AliFMDDigit(detector, ring, sector, strip, count1, count2, count3);
935 }
936
937 //____________________________________________________________________
938 void 
939 AliFMD::AddSDigit(Int_t* digits)
940 {
941   // Add a digit to the SDigit tree 
942   // 
943   // Paramters 
944   //
945   //    digits[0]  [UShort_t] Detector #
946   //    digits[1]  [Char_t]   Ring ID
947   //    digits[2]  [UShort_t] Sector #
948   //    digits[3]  [UShort_t] Strip #
949   //    digits[4]  [Float_t]  Total energy deposited 
950   //    digits[5]  [UShort_t] ADC Count 
951   //    digits[6]  [Short_t]  ADC Count, -1 if not used
952   //    digits[7]  [Short_t]  ADC Count, -1 if not used 
953   // 
954   AddSDigitByFields(UShort_t(digits[0]),  // Detector #
955                     Char_t(digits[1]),    // Ring ID
956                     UShort_t(digits[2]),  // Sector #
957                     UShort_t(digits[3]),  // Strip #
958                     Float_t(digits[4]),   // Edep
959                     UShort_t(digits[5]),  // ADC Count1 
960                     Short_t(digits[6]),   // ADC Count2 
961                     Short_t(digits[7]));  // ADC Count3 
962 }
963
964 //____________________________________________________________________
965 void 
966 AliFMD::AddSDigitByFields(UShort_t detector, 
967                           Char_t   ring, 
968                           UShort_t sector, 
969                           UShort_t strip, 
970                           Float_t  edep,
971                           UShort_t count1, 
972                           Short_t  count2,
973                           Short_t  count3)
974 {
975   // add a summable digit
976   // 
977   // Parameters 
978   //
979   //    detector  Detector # (1, 2, or 3)                      
980   //    ring      Ring ID ('I' or 'O')
981   //    sector    Sector # (For inner/outer rings: 0-19/0-39)
982   //    strip     Strip # (For inner/outer rings: 0-511/0-255)
983   //    edep      Total energy deposited
984   //    count1    ADC count (a 10-bit word)
985   //    count2    ADC count (a 10-bit word), or -1 if not used
986   //    count3    ADC count (a 10-bit word), or -1 if not used
987   //
988   TClonesArray& a = *(SDigitsArray());
989   
990   new (a[fNsdigits++]) 
991     AliFMDSDigit(detector, ring, sector, strip, edep, count1, count2, count3);
992 }
993
994 //____________________________________________________________________
995 void 
996 AliFMD::ResetSDigits()
997 {
998   //
999   // Reset number of digits and the digits array for this detector
1000   //
1001   fNsdigits   = 0;
1002   if (fSDigits) fSDigits->Clear();
1003 }
1004
1005
1006 //____________________________________________________________________
1007 TClonesArray*
1008 AliFMD::HitsArray() 
1009 {
1010   // Initialize hit array if not already, and return pointer to it. 
1011   if (!fHits) { 
1012     fHits = new TClonesArray("AliFMDHit", 1000);
1013     fNhits = 0;
1014   }
1015   return fHits;
1016 }
1017
1018 //____________________________________________________________________
1019 TClonesArray*
1020 AliFMD::DigitsArray() 
1021 {
1022   // Initialize digit array if not already, and return pointer to it. 
1023   if (!fDigits) { 
1024     fDigits = new TClonesArray("AliFMDDigit", 1000);
1025     fNdigits = 0;
1026   }
1027   return fDigits;
1028 }
1029
1030 //____________________________________________________________________
1031 TClonesArray*
1032 AliFMD::SDigitsArray() 
1033 {
1034   // Initialize digit array if not already, and return pointer to it. 
1035   if (!fSDigits) { 
1036     fSDigits = new TClonesArray("AliFMDSDigit", 1000);
1037     fNsdigits = 0;
1038   }
1039   return fSDigits;
1040 }
1041
1042 //====================================================================
1043 //
1044 // Digitization 
1045 //
1046 //____________________________________________________________________
1047 void 
1048 AliFMD::Hits2Digits() 
1049 {
1050   // Create AliFMDDigit's from AliFMDHit's.  This is done by making a
1051   // AliFMDDigitizer, and executing that code.
1052   // 
1053   Warning("Hits2Digits", "Try not to use this method.\n"
1054           "Instead, use AliSimulator");
1055   AliRunDigitizer* manager = new AliRunDigitizer(1, 1);
1056   manager->SetInputStream(0, "galice.root");
1057   manager->SetOutputFile("H2Dfile");
1058   
1059   /* AliDigitizer* dig =*/ CreateDigitizer(manager);
1060   manager->Exec("");
1061   delete manager;
1062 }
1063
1064 //____________________________________________________________________
1065 void 
1066 AliFMD::Hits2SDigits() 
1067 {
1068   // Create AliFMDSDigit's from AliFMDHit's.  This is done by creating
1069   // an AliFMDSDigitizer object, and executing it. 
1070   // 
1071   AliFMDSDigitizer* digitizer = new AliFMDSDigitizer("galice.root");
1072   digitizer->Exec("");
1073   delete digitizer;
1074 }
1075
1076   
1077 //____________________________________________________________________
1078 AliDigitizer* 
1079 AliFMD::CreateDigitizer(AliRunDigitizer* manager) const
1080 {
1081   // Create a digitizer object 
1082   AliFMDDigitizer* digitizer = new AliFMDDigitizer(manager);
1083   return digitizer;
1084 }
1085
1086 //====================================================================
1087 //
1088 // Raw data simulation 
1089 //
1090 //__________________________________________________________________
1091 void 
1092 AliFMD::Digits2Raw() 
1093 {
1094   // Turn digits into raw data. 
1095   // 
1096   // This uses the class AliFMDRawWriter to do the job.   Please refer
1097   // to that class for more information. 
1098   AliFMDRawWriter writer(this);
1099   writer.Exec();
1100 }
1101
1102
1103 //====================================================================
1104 //
1105 // Utility 
1106 //
1107 //__________________________________________________________________
1108 void 
1109 AliFMD::Browse(TBrowser* b) 
1110 {
1111   // Browse this object. 
1112   //
1113   AliDebug(30, "\tBrowsing the FMD");
1114   AliDetector::Browse(b);
1115 #ifdef USE_PRE_MOVE
1116   if (fSimulator) b->Add(fSimulator);
1117 #endif
1118   b->Add(AliFMDGeometry::Instance());
1119 }
1120
1121 //___________________________________________________________________
1122 //
1123 // EOF
1124 //