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 <AliLog.h>             // ALILOG_H
 111 #include "AliFMD.h"             // ALIFMD_H
 112 #include "AliFMDDigit.h"        // ALIFMDDIGIG_H
 113 #include "AliFMDHit.h"          // ALIFMDHIT_H
 114 #include "AliFMDGeometry.h"     // ALIFMDGEOMETRY_H
 115 #include "AliFMDDetector.h"     // ALIFMDDETECTOR_H
 116 #include "AliFMDRing.h"         // ALIFMDRING_H
 117 #include "AliFMDDigitizer.h"    // ALIFMDDIGITIZER_H
 118 #include "AliFMDSimulator.h"    // ALIFMDSIMULATOR_H
 119 #include "AliFMDG3Simulator.h"  // ALIFMDG3SIMULATOR_H
 120 #include "AliFMDGeoSimulator.h" // ALIFMDGEOSIMULATOR_H
 121 #include "AliFMDG3OldSimulator.h"       // ALIFMDG3OLDSIMULATOR_H
 122 #include "AliFMDGeoOldSimulator.h"      // ALIFMDGEOOLDSIMULATOR_H
 123 #include "AliFMDRawWriter.h"    // ALIFMDRAWWRITER_H
 124
 125 //____________________________________________________________________
 126 ClassImp(AliFMD)
 127 #if 0
 128   ; // This is to keep Emacs from indenting the next line
 129 #endif
 130
 131 //____________________________________________________________________
 132 AliFMD::AliFMD()
 133   : AliDetector(),
 134     fSDigits(0),
 135     fNsdigits(0),
 136     fDetailed(kTRUE),
 137     fSimulator(0)
 138 {
 139   //
 140   // Default constructor for class AliFMD
 141   //
 142   AliDebug(10, "\tDefault CTOR");
 143   fHits        = 0;
 144   fDigits      = 0;
 145   fIshunt      = 0;
 146   fUseOld      = kFALSE;
 147   fUseDivided  = kFALSE;
 148   fUseAssembly = kFALSE;
 149   fUseGeo      = kTRUE;
 150 }
 151
 152 //____________________________________________________________________
 153 AliFMD::AliFMD(const AliFMD& other)
 154   : AliDetector(other),
 155     fSDigits(other.fSDigits),
 156     fNsdigits(other.fNsdigits),
 157     fDetailed(other.fDetailed),
 158     fSimulator(other.fSimulator)
 159 {
 160   // Copy constructor
 161   fUseOld      = other.fUseOld;
 162   fUseDivided  = other.fUseDivided;
 163   fUseAssembly = other.fUseAssembly;
 164   fUseGeo      = other.fUseGeo;
 165 }
 166
 167 //____________________________________________________________________
 168 AliFMD::AliFMD(const char *name, const char *title)
 169   : AliDetector (name, title),
 170     fSDigits(0),
 171     fNsdigits(0),
 172     fDetailed(kTRUE),
 173     fSimulator(0)
 174 {
 175   //
 176   // Standard constructor for Forward Multiplicity Detector
 177   //
 178   AliDebug(10, "\tStandard CTOR");
 179   fUseOld      = kFALSE;
 180   fUseDivided  = kFALSE;
 181   fUseAssembly = kFALSE;
 182   fUseGeo      = kTRUE;
 183
 184   // Initialise Hit array
 185   HitsArray();
 186   gAlice->GetMCApp()->AddHitList(fHits);
 187
 188   // (S)Digits for the detectors disk
 189   DigitsArray();
 190   SDigitsArray();
 191
 192   // CHC: What is this?
 193   fIshunt = 0;
 194   SetMarkerColor(kRed);
 195   SetLineColor(kYellow);
 196 }
 197
 198 //____________________________________________________________________
 199 AliFMD::~AliFMD ()
 200 {
 201   // Destructor for base class AliFMD
 202   if (fHits) {
 203     fHits->Delete();
 204     delete fHits;
 205     fHits = 0;
 206   }
 207   if (fDigits) {
 208     fDigits->Delete();
 209     delete fDigits;
 210     fDigits = 0;
 211   }
 212   if (fSDigits) {
 213     fSDigits->Delete();
 214     delete fSDigits;
 215     fSDigits = 0;
 216   }
 217 }
 218
 219 //____________________________________________________________________
 220 AliFMD&
 221 AliFMD::operator=(const AliFMD& other)
 222 {
 223   AliDetector::operator=(other);
 224   fSDigits              = other.fSDigits;
 225   fNsdigits             = other.fNsdigits;
 226   fDetailed             = other.fDetailed;
 227   fSimulator            = other.fSimulator;
 228
 229   return *this;
 230 }
 231
 232 //====================================================================
 233 //
 234 // GEometry ANd Traking
 235 //
 236 //____________________________________________________________________
 237 void
 238 AliFMD::CreateGeometry()
 239 {
 240   //
 241   // Create the geometry of Forward Multiplicity Detector.  The actual
 242   // construction of the geometry is delegated to the class AliFMDRing
 243   // and AliFMDSubDetector and the relevant derived classes.
 244   //
 245   // The flow of this member function is:
 246   //
 247   //   FOR rings fInner and fOuter DO
 248   //     AliFMDRing::Init();
 249   //   END FOR
 250   //
 251   //   Set up hybrud card support (leg) volume shapes
 252   //
 253   //   FOR rings fInner and fOuter DO
 254   //     AliFMDRing::SetupGeometry();
 255   //   END FOR
 256   //
 257   //   FOR subdetectors fFMD1, fFMD2, and fFMD3 DO
 258   //     AliFMDSubDetector::SetupGeomtry();
 259   //   END FOR
 260   //
 261   //   FOR subdetectors fFMD1, fFMD2, and fFMD3 DO
 262   //     AliFMDSubDetector::Geomtry();
 263   //   END FOR
 264   //
 265   if (!fSimulator) {
 266     AliFatal("Simulator object not made yet!");
 267     return;
 268   }
 269   fSimulator->DefineGeometry();
 270 }
 271
 272 //____________________________________________________________________
 273 void AliFMD::CreateMaterials()
 274 {
 275   // Register various materials and tracking mediums with the
 276   // backend.
 277   //
 278   AliDebug(10, "\tCreating materials");
 279
 280   if (fSimulator) {
 281     AliFatal("Simulator object already instantised!");
 282     return;
 283   }
 284   AliFMDGeometry* geometry = AliFMDGeometry::Instance();
 285   geometry->Init();
 286   TVirtualMC* mc = TVirtualMC::GetMC();
 287   Bool_t geo = mc->IsRootGeometrySupported();
 288   if (geo && fUseGeo) {
 289     if (fUseOld)
 290       fSimulator = new AliFMDGeoOldSimulator(this, fDetailed);
 291     else
 292       fSimulator = new AliFMDGeoSimulator(this, fDetailed);
 293   }
 294   else {
 295     if (fUseOld)
 296       fSimulator = new AliFMDG3OldSimulator(this, fDetailed);
 297     else
 298       fSimulator = new AliFMDG3Simulator(this, fDetailed);
 299   }
 300   AliDebug(1, Form("using a %s as simulation backend",
 301                    fSimulator->IsA()->GetName()));
 302   fSimulator->UseDivided(fUseDivided);
 303   fSimulator->UseAssembly(fUseAssembly);
 304   fSimulator->DefineMaterials();
 305 }
 306
 307 //____________________________________________________________________
 308 void
 309 AliFMD::Init()
 310 {
 311   //
 312   // Initialis the FMD after it has been built
 313   Int_t i;
 314   //
 315   if (AliLog::GetGlobalDebugLevel()) {
 316     cout << "\n" << ClassName() << ": " << flush;
 317     for (i = 0; i < 35; i++) cout << "*";
 318     cout << " FMD_INIT ";
 319     for (i = 0; i < 35; i++) cout << "*";
 320     cout << "\n" << ClassName() << ": " << flush;
 321     //
 322     // Here the FMD initialisation code (if any!)
 323     for (i = 0; i < 80; i++) cout << "*";
 324     cout << endl;
 325   }
 326   //
 327   //
 328 }
 329
 330 //____________________________________________________________________
 331 void
 332 AliFMD::FinishEvent()
 333 {
 334   if (fSimulator) fSimulator->EndEvent();
 335 }
 336
 337
 338 //====================================================================
 339 //
 340 // Graphics and event display
 341 //
 342 //____________________________________________________________________
 343 void
 344 AliFMD::BuildGeometry()
 345 {
 346   //
 347   // Build simple ROOT TNode geometry for event display
 348   //
 349   // Build a simplified geometry of the FMD used for event display
 350   //
 351   // The actual building of the TNodes is done by
 352   // AliFMDSubDetector::SimpleGeometry.
 353   AliDebug(10, "\tCreating a simplified geometry");
 354
 355   AliFMDGeometry* fmd = AliFMDGeometry::Instance();
 356
 357   static TXTRU*     innerShape = 0;
 358   static TXTRU*     outerShape = 0;
 359   static TObjArray* innerRot   = 0;
 360   static TObjArray* outerRot   = 0;
 361
 362   if (!innerShape || !outerShape) {
 363     // Make the shapes for the modules
 364     for (Int_t i = 0; i < 2; i++) {
 365       AliFMDRing* r = 0;
 366       switch (i) {
 367       case 0: r = fmd->GetRing('I'); break;
 368       case 1: r = fmd->GetRing('O'); break;
 369       }
 370       if (!r) {
 371         AliError(Form("no ring found for i=%d", i));
 372         return;
 373       }
 374       Double_t    siThick  = r->GetSiThickness();
 375       const Int_t nv       = r->GetNVerticies();
 376       Double_t    theta    = r->GetTheta();
 377       Int_t       nmod     = r->GetNModules();
 378
 379       TXTRU* shape = new TXTRU(r->GetName(), r->GetTitle(), "void", nv, 2);
 380       for (Int_t j = 0; j < nv; j++) {
 381         TVector2* vv = r->GetVertex(nv - 1 - j);
 382         shape->DefineVertex(j, vv->X(), vv->Y());
 383       }
 384       shape->DefineSection(0, -siThick / 2, 1, 0, 0);
 385       shape->DefineSection(1, +siThick / 2, 1, 0, 0);
 386       shape->SetLineColor(GetLineColor());
 387
 388       TObjArray* rots = new TObjArray(nmod);
 389       for (Int_t j = 0; j < nmod; j++) {
 390         Double_t th = (j + .5) * theta * 2;
 391         TString name(Form("FMD_ring_%c_rot_%02d", r->GetId(), j));
 392         TString title(Form("FMD Ring %c Rotation # %d", r->GetId(), j));
 393         TRotMatrix* rot = new TRotMatrix(name.Data(), title.Data(),
 394                                          90, th, 90, fmod(90+th,360), 0, 0);
 395         rots->AddAt(rot, j);
 396       }
 397
 398       switch (r->GetId()) {
 399       case 'i':
 400       case 'I': innerShape = shape; innerRot = rots; break;
 401       case 'o':
 402       case 'O': outerShape = shape; outerRot = rots; break;
 403       }
 404     }
 405   }
 406
 407   TNode* top = gAlice->GetGeometry()->GetNode("alice");
 408
 409   for (Int_t i = 1; i <= 3; i++) {
 410     AliFMDDetector* det = fmd->GetDetector(i);
 411     if (!det) {
 412       Warning("BuildGeometry", "FMD%d seems to be disabled", i);
 413       continue;
 414     }
 415     Double_t w  = 0;
 416     Double_t rh = det->GetRing('I')->GetHighR();
 417     Char_t   id = 'I';
 418     if (det->GetRing('O')) {
 419       w  = TMath::Abs(det->GetRingZ('O') - det->GetRingZ('I'));
 420       id = (TMath::Abs(det->GetRingZ('O'))
 421             > TMath::Abs(det->GetRingZ('I')) ? 'O' : 'I');
 422       rh = det->GetRing('O')->GetHighR();
 423     }
 424     w += (det->GetRing(id)->GetModuleSpacing() +
 425           det->GetRing(id)->GetSiThickness());
 426     TShape* shape = new TTUBE(det->GetName(), det->GetTitle(), "void",
 427                               det->GetRing('I')->GetLowR(), rh, w / 2);
 428     Double_t z = (det->GetRingZ('I') - w / 2);
 429     if (z > 0) z += det->GetRing(id)->GetModuleSpacing();
 430     top->cd();
 431     TNode* node = new TNode(det->GetName(), det->GetTitle(), shape,
 432                             0, 0, z, 0);
 433     fNodes->Add(node);
 434
 435     for (Int_t j = 0; j < 2; j++) {
 436       AliFMDRing* r      = 0;
 437       TShape*     rshape = 0;
 438       TObjArray*  rots   = 0;
 439       switch (j) {
 440       case 0:
 441         r = det->GetRing('I'); rshape = innerShape; rots = innerRot; break;
 442       case 1:
 443         r = det->GetRing('O'); rshape = outerShape; rots = outerRot; break;
 444       }
 445       if (!r) continue;
 446
 447       Double_t    siThick  = r->GetSiThickness();
 448       Int_t       nmod     = r->GetNModules();
 449       Double_t    modspace = r->GetModuleSpacing();
 450       Double_t    rz       = - (z - det->GetRingZ(r->GetId()));
 451
 452       for (Int_t k = 0; k < nmod; k++) {
 453         node->cd();
 454         Double_t    offz    = (k % 2 == 1 ? modspace : 0);
 455         TRotMatrix* rot     = static_cast<TRotMatrix*>(rots->At(k));
 456         TString name(Form("%s%c_module_%02d", det->GetName(), r->GetId(),k));
 457         TString title(Form("%s%c Module %d", det->GetName(), r->GetId(),k));
 458         TNode* mnod = new TNode(name.Data(), title.Data(), rshape,
 459                                 0, 0, rz - siThick / 2
 460                                 + TMath::Sign(offz,z), rot);
 461         mnod->SetLineColor(GetLineColor());
 462         fNodes->Add(mnod);
 463       } // for (Int_t k = 0 ; ...)
 464     } // for (Int_t j = 0 ; ...)
 465   } // for (Int_t i = 1 ; ...)
 466 }
 467
 468 //____________________________________________________________________
 469 void
 470 AliFMD::DrawDetector()
 471 {
 472   //
 473   // Draw a shaded view of the Forward multiplicity detector
 474   //
 475   // DebugGuard guard("AliFMD::DrawDetector");
 476   AliDebug(10, "\tDraw detector");
 477
 478 #if 0
 479   //Set ALIC mother transparent
 480   gMC->Gsatt("ALIC","SEEN",0);
 481   //
 482   gMC->Gdopt("hide", "on");
 483   gMC->Gdopt("shad", "on");
 484   gMC->Gsatt("*", "fill", 7);
 485   gMC->SetClipBox(".");
 486   gMC->SetClipBox("*", 0, 1000, -1000, 1000, -1000, 1000);
 487   gMC->DefaultRange();
 488   gMC->Gdraw("alic", 40, 30, 0, 12, 12, .055, .055);
 489   gMC->Gdhead(1111, "Forward Multiplicity Detector");
 490   gMC->Gdman(16, 10, "MAN");
 491   gMC->Gdopt("hide", "off");
 492 #endif
 493 }
 494
 495 //____________________________________________________________________
 496 Int_t
 497 AliFMD::DistanceToPrimitive(Int_t, Int_t)
 498 {
 499   //
 500   // Calculate the distance from the mouse to the FMD on the screen
 501   // Dummy routine
 502   //
 503   return 9999;
 504 }
 505
 506 //====================================================================
 507 //
 508 // Hit and Digit managment
 509 //
 510 //____________________________________________________________________
 511 void
 512 AliFMD::MakeBranch(Option_t * option)
 513 {
 514   // Create Tree branches for the FMD.
 515   //
 516   // Options:
 517   //
 518   //    H          Make a branch of TClonesArray of AliFMDHit's
 519   //    D          Make a branch of TClonesArray of AliFMDDigit's
 520   //    S          Make a branch of TClonesArray of AliFMDSDigit's
 521   //
 522   const Int_t kBufferSize = 16000;
 523   TString branchname(GetName());
 524   TString opt(option);
 525
 526   if (opt.Contains("H", TString::kIgnoreCase)) {
 527     HitsArray();
 528     AliDetector::MakeBranch(option);
 529   }
 530   if (opt.Contains("D", TString::kIgnoreCase)) {
 531     DigitsArray();
 532     MakeBranchInTree(fLoader->TreeD(), branchname.Data(),
 533                      &fDigits, kBufferSize, 0);
 534   }
 535   if (opt.Contains("S", TString::kIgnoreCase)) {
 536     SDigitsArray();
 537     MakeBranchInTree(fLoader->TreeS(), branchname.Data(),
 538                      &fSDigits, kBufferSize, 0);
 539   }
 540 }
 541
 542 //____________________________________________________________________
 543 void
 544 AliFMD::SetTreeAddress()
 545 {
 546   // Set branch address for the Hits, Digits, and SDigits Tree.
 547   if (fLoader->TreeH()) HitsArray();
 548   AliDetector::SetTreeAddress();
 549
 550   TTree *treeD = fLoader->TreeD();
 551   if (treeD) {
 552     DigitsArray();
 553     TBranch* branch = treeD->GetBranch ("FMD");
 554     if (branch) branch->SetAddress(&fDigits);
 555   }
 556
 557   TTree *treeS = fLoader->TreeS();
 558   if (treeS) {
 559     SDigitsArray();
 560     TBranch* branch = treeS->GetBranch ("FMD");
 561     if (branch) branch->SetAddress(&fSDigits);
 562   }
 563 }
 564
 565
 566
 567 //____________________________________________________________________
 568 void
 569 AliFMD::SetHitsAddressBranch(TBranch *b)
 570 {
 571   // Set the TClonesArray to read hits into.
 572   b->SetAddress(&fHits);
 573 }
 574
 575 //____________________________________________________________________
 576 void
 577 AliFMD::AddHit(Int_t track, Int_t *vol, Float_t *hits)
 578 {
 579   // Add a hit to the hits tree
 580   //
 581   // The information of the two arrays are decoded as
 582   //
 583   // Parameters
 584   //    track                Track #
 585   //    ivol[0]  [UShort_t ] Detector #
 586   //    ivol[1]  [Char_t   ] Ring ID
 587   //    ivol[2]  [UShort_t ] Sector #
 588   //    ivol[3]  [UShort_t ] Strip #
 589   //    hits[0]  [Float_t  ] Track's X-coordinate at hit
 590   //    hits[1]  [Float_t  ] Track's Y-coordinate at hit
 591   //    hits[3]  [Float_t  ] Track's Z-coordinate at hit
 592   //    hits[4]  [Float_t  ] X-component of track's momentum
 593   //    hits[5]  [Float_t  ] Y-component of track's momentum
 594   //    hits[6]  [Float_t  ] Z-component of track's momentum
 595   //    hits[7]  [Float_t  ] Energy deposited by track
 596   //    hits[8]  [Int_t    ] Track's particle Id #
 597   //    hits[9]  [Float_t  ] Time when the track hit
 598   //
 599   //
 600   AddHitByFields(track,
 601                  UShort_t(vol[0]),  // Detector #
 602                  Char_t(vol[1]),    // Ring ID
 603                  UShort_t(vol[2]),  // Sector #
 604                  UShort_t(vol[3]),  // Strip #
 605                  hits[0],           // X
 606                  hits[1],           // Y
 607                  hits[2],           // Z
 608                  hits[3],           // Px
 609                  hits[4],           // Py
 610                  hits[5],           // Pz
 611                  hits[6],           // Energy loss
 612                  Int_t(hits[7]),    // PDG
 613                  hits[8]);          // Time
 614 }
 615
 616 //____________________________________________________________________
 617 AliFMDHit*
 618 AliFMD::AddHitByFields(Int_t    track,
 619                        UShort_t detector,
 620                        Char_t   ring,
 621                        UShort_t sector,
 622                        UShort_t strip,
 623                        Float_t  x,
 624                        Float_t  y,
 625                        Float_t  z,
 626                        Float_t  px,
 627                        Float_t  py,
 628                        Float_t  pz,
 629                        Float_t  edep,
 630                        Int_t    pdg,
 631                        Float_t  t)
 632 {
 633   //
 634   // Add a hit to the list
 635   //
 636   // Parameters:
 637   //
 638   //    track     Track #
 639   //    detector  Detector # (1, 2, or 3)
 640   //    ring      Ring ID ('I' or 'O')
 641   //    sector    Sector # (For inner/outer rings: 0-19/0-39)
 642   //    strip     Strip # (For inner/outer rings: 0-511/0-255)
 643   //    x         Track's X-coordinate at hit
 644   //    y         Track's Y-coordinate at hit
 645   //    z         Track's Z-coordinate at hit
 646   //    px        X-component of track's momentum
 647   //    py        Y-component of track's momentum
 648   //    pz        Z-component of track's momentum
 649   //    edep      Energy deposited by track
 650   //    pdg       Track's particle Id #
 651   //    t         Time when the track hit
 652   //
 653   TClonesArray& a = *(HitsArray());
 654   // Search through the list of already registered hits, and see if we
 655   // find a hit with the same parameters.  If we do, then don't create
 656   // a new hit, but rather update the energy deposited in the hit.
 657   // This is done, so that a FLUKA based simulation will get the
 658   // number of hits right, not just the enerrgy deposition.
 659   AliFMDHit* hit = 0;
 660   for (Int_t i = 0; i < fNhits; i++) {
 661     if (!a.At(i)) continue;
 662     hit = static_cast<AliFMDHit*>(a.At(i));
 663     if (hit->Detector() == detector
 664         && hit->Ring() == ring
 665         && hit->Sector() == sector
 666         && hit->Strip() == strip
 667         && hit->Track() == track) {
 668       Warning("AddHit", "already had a hit in FMD%d%c[%2d,%3d] for track # %d,"
 669               " adding energy (%f) to that hit (%f) -> %f",
 670               detector, ring, sector, strip, track, edep, hit->Edep(),
 671               hit->Edep() + edep);
 672       hit->SetEdep(hit->Edep() + edep);
 673       return hit;
 674     }
 675   }
 676   // If hit wasn't already registered, do so know.
 677   hit = new (a[fNhits]) AliFMDHit(fIshunt, track, detector, ring, sector,
 678                                   strip, x, y, z, px, py, pz, edep, pdg, t);
 679   fNhits++;
 680   return hit;
 681 }
 682
 683 //____________________________________________________________________
 684 void
 685 AliFMD::AddDigit(Int_t* digits, Int_t*)
 686 {
 687   // Add a digit to the Digit tree
 688   //
 689   // Paramters
 690   //
 691   //    digits[0]  [UShort_t] Detector #
 692   //    digits[1]  [Char_t]   Ring ID
 693   //    digits[2]  [UShort_t] Sector #
 694   //    digits[3]  [UShort_t] Strip #
 695   //    digits[4]  [UShort_t] ADC Count
 696   //    digits[5]  [Short_t]  ADC Count, -1 if not used
 697   //    digits[6]  [Short_t]  ADC Count, -1 if not used
 698   //
 699   AddDigitByFields(UShort_t(digits[0]),  // Detector #
 700                    Char_t(digits[1]),    // Ring ID
 701                    UShort_t(digits[2]),  // Sector #
 702                    UShort_t(digits[3]),  // Strip #
 703                    UShort_t(digits[4]),  // ADC Count1
 704                    Short_t(digits[5]),   // ADC Count2
 705                    Short_t(digits[6]));  // ADC Count3
 706 }
 707
 708 //____________________________________________________________________
 709 void
 710 AliFMD::AddDigitByFields(UShort_t detector,
 711                          Char_t   ring,
 712                          UShort_t sector,
 713                          UShort_t strip,
 714                          UShort_t count1,
 715                          Short_t  count2,
 716                          Short_t  count3)
 717 {
 718   // add a real digit - as coming from data
 719   //
 720   // Parameters
 721   //
 722   //    detector  Detector # (1, 2, or 3)
 723   //    ring      Ring ID ('I' or 'O')
 724   //    sector    Sector # (For inner/outer rings: 0-19/0-39)
 725   //    strip     Strip # (For inner/outer rings: 0-511/0-255)
 726   //    count1    ADC count (a 10-bit word)
 727   //    count2    ADC count (a 10-bit word), or -1 if not used
 728   //    count3    ADC count (a 10-bit word), or -1 if not used
 729   TClonesArray& a = *(DigitsArray());
 730
 731   new (a[fNdigits++])
 732     AliFMDDigit(detector, ring, sector, strip, count1, count2, count3);
 733 }
 734
 735 //____________________________________________________________________
 736 void
 737 AliFMD::AddSDigit(Int_t* digits)
 738 {
 739   // Add a digit to the SDigit tree
 740   //
 741   // Paramters
 742   //
 743   //    digits[0]  [UShort_t] Detector #
 744   //    digits[1]  [Char_t]   Ring ID
 745   //    digits[2]  [UShort_t] Sector #
 746   //    digits[3]  [UShort_t] Strip #
 747   //    digits[4]  [Float_t]  Total energy deposited
 748   //    digits[5]  [UShort_t] ADC Count
 749   //    digits[6]  [Short_t]  ADC Count, -1 if not used
 750   //    digits[7]  [Short_t]  ADC Count, -1 if not used
 751   //
 752   AddSDigitByFields(UShort_t(digits[0]),  // Detector #
 753                     Char_t(digits[1]),    // Ring ID
 754                     UShort_t(digits[2]),  // Sector #
 755                     UShort_t(digits[3]),  // Strip #
 756                     Float_t(digits[4]),   // Edep
 757                     UShort_t(digits[5]),  // ADC Count1
 758                     Short_t(digits[6]),   // ADC Count2
 759                     Short_t(digits[7]));  // ADC Count3
 760 }
 761
 762 //____________________________________________________________________
 763 void
 764 AliFMD::AddSDigitByFields(UShort_t detector,
 765                           Char_t   ring,
 766                           UShort_t sector,
 767                           UShort_t strip,
 768                           Float_t  edep,
 769                           UShort_t count1,
 770                           Short_t  count2,
 771                           Short_t  count3)
 772 {
 773   // add a summable digit
 774   //
 775   // Parameters
 776   //
 777   //    detector  Detector # (1, 2, or 3)
 778   //    ring      Ring ID ('I' or 'O')
 779   //    sector    Sector # (For inner/outer rings: 0-19/0-39)
 780   //    strip     Strip # (For inner/outer rings: 0-511/0-255)
 781   //    edep      Total energy deposited
 782   //    count1    ADC count (a 10-bit word)
 783   //    count2    ADC count (a 10-bit word), or -1 if not used
 784   //    count3    ADC count (a 10-bit word), or -1 if not used
 785   //
 786   TClonesArray& a = *(SDigitsArray());
 787
 788   new (a[fNsdigits++])
 789     AliFMDSDigit(detector, ring, sector, strip, edep, count1, count2, count3);
 790 }
 791
 792 //____________________________________________________________________
 793 void
 794 AliFMD::ResetSDigits()
 795 {
 796   //
 797   // Reset number of digits and the digits array for this detector
 798   //
 799   fNsdigits   = 0;
 800   if (fSDigits) fSDigits->Clear();
 801 }
 802
 803
 804 //____________________________________________________________________
 805 TClonesArray*
 806 AliFMD::HitsArray()
 807 {
 808   // Initialize hit array if not already, and return pointer to it.
 809   if (!fHits) {
 810     fHits = new TClonesArray("AliFMDHit", 1000);
 811     fNhits = 0;
 812   }
 813   return fHits;
 814 }
 815
 816 //____________________________________________________________________
 817 TClonesArray*
 818 AliFMD::DigitsArray()
 819 {
 820   // Initialize digit array if not already, and return pointer to it.
 821   if (!fDigits) {
 822     fDigits = new TClonesArray("AliFMDDigit", 1000);
 823     fNdigits = 0;
 824   }
 825   return fDigits;
 826 }
 827
 828 //____________________________________________________________________
 829 TClonesArray*
 830 AliFMD::SDigitsArray()
 831 {
 832   // Initialize digit array if not already, and return pointer to it.
 833   if (!fSDigits) {
 834     fSDigits = new TClonesArray("AliFMDSDigit", 1000);
 835     fNsdigits = 0;
 836   }
 837   return fSDigits;
 838 }
 839
 840 //====================================================================
 841 //
 842 // Digitization
 843 //
 844 //____________________________________________________________________
 845 void
 846 AliFMD::Hits2Digits()
 847 {
 848   // Create AliFMDDigit's from AliFMDHit's.  This is done by making a
 849   // AliFMDDigitizer, and executing that code.
 850   //
 851   Warning("Hits2Digits", "Try not to use this method.\n"
 852           "Instead, use AliSimulator");
 853   AliRunDigitizer* manager = new AliRunDigitizer(1, 1);
 854   manager->SetInputStream(0, "galice.root");
 855   manager->SetOutputFile("H2Dfile");
 856
 857   /* AliDigitizer* dig =*/ CreateDigitizer(manager);
 858   manager->Exec("");
 859   delete manager;
 860 }
 861
 862 //____________________________________________________________________
 863 void
 864 AliFMD::Hits2SDigits()
 865 {
 866   // Create AliFMDSDigit's from AliFMDHit's.  This is done by creating
 867   // an AliFMDSDigitizer object, and executing it.
 868   //
 869   AliFMDSDigitizer* digitizer = new AliFMDSDigitizer("galice.root");
 870   digitizer->Exec("");
 871   delete digitizer;
 872 }
 873
 874
 875 //____________________________________________________________________
 876 AliDigitizer*
 877 AliFMD::CreateDigitizer(AliRunDigitizer* manager) const
 878 {
 879   // Create a digitizer object
 880   AliFMDDigitizer* digitizer = new AliFMDDigitizer(manager);
 881   return digitizer;
 882 }
 883
 884 //====================================================================
 885 //
 886 // Raw data simulation
 887 //
 888 //__________________________________________________________________
 889 void
 890 AliFMD::Digits2Raw()
 891 {
 892   // Turn digits into raw data.
 893   //
 894   // This uses the class AliFMDRawWriter to do the job.   Please refer
 895   // to that class for more information.
 896   AliFMDRawWriter writer(this);
 897   writer.Exec();
 898 }
 899
 900
 901 //====================================================================
 902 //
 903 // Utility
 904 //
 905 //__________________________________________________________________
 906 void
 907 AliFMD::Browse(TBrowser* b)
 908 {
 909   // Browse this object.
 910   //
 911   AliDebug(30, "\tBrowsing the FMD");
 912   AliDetector::Browse(b);
 913   if (fSimulator) b->Add(fSimulator);
 914   b->Add(AliFMDGeometry::Instance());
 915 }
 916
 917 //___________________________________________________________________
 918 //
 919 // EOF
 920 //