]> git.uio.no Git - u/mrichter/AliRoot.git/blobdiff - TRD/AliTRD.cxx
Correction connected with compiler warnings on Darwin
[u/mrichter/AliRoot.git] / TRD / AliTRD.cxx
index efa195ad2243a970ba10fd5fced4e08a9646b5bf..f7b5e710f60c416dfee45ee768916baa788d6710 100644 (file)
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
 
-/*
-$Log$
-Revision 1.28  2001/05/16 14:57:27  alibrary
-New files for folders and Stack
-
-Revision 1.27  2001/05/08 07:05:02  hristov
-Loop variable declared once (HP, Sun)
-
-Revision 1.26  2001/05/07 08:03:22  cblume
-Generate also hits in the amplification region
-
-Revision 1.25  2001/03/13 09:30:35  cblume
-Update of digitization. Moved digit branch definition to AliTRD
-
-Revision 1.24  2001/01/26 19:56:49  hristov
-Major upgrade of AliRoot code
-
-Revision 1.23  2000/11/01 14:53:20  cblume
-Merge with TRD-develop
-
-Revision 1.17.2.6  2000/10/15 23:29:08  cblume
-Introduced more detailed geometry for the display
-
-Revision 1.17.2.5  2000/10/06 16:49:46  cblume
-Made Getters const
-
-Revision 1.17.2.4  2000/10/04 16:34:57  cblume
-Replace include files by forward declarations
-
-Revision 1.17.2.3  2000/09/22 14:45:17  cblume
-Included changes for the tracking
-
-Revision 1.17.2.2  2000/09/18 13:25:13  cblume
-Included LoadPoints() method to display the TR photons
-
-Revision 1.22  2000/10/02 21:28:19  fca
-Removal of useless dependecies via forward declarations
-
-Revision 1.21  2000/06/09 11:10:07  cblume
-Compiler warnings and coding conventions, next round
-
-Revision 1.20  2000/06/08 18:32:57  cblume
-Make code compliant to coding conventions
-
-Revision 1.19  2000/06/07 16:25:37  cblume
-Try to remove compiler warnings on Sun and HP
-
-Revision 1.18  2000/05/08 16:17:27  cblume
-Merge TRD-develop
-
-Revision 1.21  2000/06/09 11:10:07  cblume
-Compiler warnings and coding conventions, next round
-
-Revision 1.20  2000/06/08 18:32:57  cblume
-Make code compliant to coding conventions
-
-Revision 1.19  2000/06/07 16:25:37  cblume
-Try to remove compiler warnings on Sun and HP
-
-Revision 1.18  2000/05/08 16:17:27  cblume
-Merge TRD-develop
-
-Revision 1.17.2.1  2000/05/08 14:28:59  cblume
-Introduced SetPHOShole() and SetRICHhole(). AliTRDrecPoint container is now a TObjArray
-
-Revision 1.17  2000/02/28 19:10:26  cblume
-Include the new TRD classes
-
-Revision 1.16.2.2  2000/02/28 17:53:24  cblume
-Introduce TRD geometry classes
-
-Revision 1.16.2.1  2000/02/28 17:04:19  cblume
-Include functions and data members for AliTRDrecPoint
-
-Revision 1.16  2000/01/19 17:17:35  fca
-Introducing a list of lists of hits -- more hits allowed for detector now
-
-Revision 1.15  1999/11/02 17:04:25  fca
-Small syntax change for HP compiler
-
-Revision 1.14  1999/11/02 16:57:02  fca
-Avoid non ansi warnings on HP compilers
-
-Revision 1.13  1999/11/02 16:35:56  fca
-New version of TRD introduced
-
-Revision 1.12  1999/11/01 20:41:51  fca
-Added protections against using the wrong version of FRAME
-
-Revision 1.11  1999/09/29 09:24:34  fca
-Introduction of the Copyright and cvs Log
-
-*/
+/* $Id$ */
 
 ///////////////////////////////////////////////////////////////////////////////
 //                                                                           //
@@ -116,33 +24,37 @@ Introduction of the Copyright and cvs Log
 ///////////////////////////////////////////////////////////////////////////////
 
 #include <stdlib.h>
-#include <iostream.h>
+#include <Riostream.h>
 
+#include <TFile.h>
+#include <TGeometry.h>
+#include <TLorentzVector.h>
 #include <TMath.h>
 #include <TNode.h>
-#include <TGeometry.h>
-#include <TTree.h>                                                              
 #include <TPGON.h> 
-
-#include "AliRun.h"
+#include <TParticle.h>
+#include <TROOT.h>
+#include <TTree.h>
+#include <TVirtualMC.h>
 #include "AliConst.h"
 #include "AliDigit.h"
+#include "AliLoader.h"
 #include "AliMagF.h"
-#include "AliMC.h"                                                              
+#include "AliRun.h"
 #include "AliTRD.h"
-#include "AliTRDhit.h"
-#include "AliTRDpoints.h"
+#include "AliTRDcluster.h"
+#include "AliTRDclusterizer.h"
 #include "AliTRDdigit.h"
 #include "AliTRDdigitizer.h"
-#include "AliTRDclusterizer.h"
-#include "AliTRDgeometryHole.h"
+#include "AliTRDdigitsManager.h"
 #include "AliTRDgeometryFull.h"
+#include "AliTRDgeometryHole.h"
+#include "AliTRDhit.h"
+#include "AliTRDpoints.h"
 #include "AliTRDrecPoint.h"
-#include "AliTRDcluster.h"
-#include "AliTRDdigitsManager.h"
-#include "AliTRDdataArrayI.h"
-#include "AliTRDsegmentArray.h"
+#include "AliTRDtrackHits.h"  
+#include "AliTrackReference.h"
 
 ClassImp(AliTRD)
  
@@ -167,12 +79,10 @@ AliTRD::AliTRD()
   fFoilDensity   = 0;
 
   fDrawTR        = 0;
-  fDisplayType   = 0; 
-
-  fDigitsArray   = 0; 
-  for (Int_t iDict = 0; iDict < AliTRDdigitsManager::NDict(); iDict++) {
-    fDictionaryArray[iDict] = 0; 
-  }
+  fDisplayType   = 0;
+  fTrackHits     = 0; 
+  fHitType       = 0; 
 
 }
  
@@ -226,10 +136,8 @@ AliTRD::AliTRD(const char *name, const char *title)
   fDrawTR        = 0;
   fDisplayType   = 0;
 
-  fDigitsArray   = 0; 
-  for (Int_t iDict = 0; iDict < AliTRDdigitsManager::NDict(); iDict++) {
-    fDictionaryArray[iDict] = 0; 
-  }
+  fTrackHits     = 0;
+  fHitType       = 2;
 
   SetMarkerColor(kWhite);   
 
@@ -255,48 +163,43 @@ AliTRD::~AliTRD()
 
   fIshunt = 0;
 
-  delete fGeometry;
-  delete fHits;
-  delete fRecPoints;
-  if (fDigitsArray) delete fDigitsArray;
-  for (Int_t iDict = 0; iDict < AliTRDdigitsManager::NDict(); iDict++) {
-    if (fDictionaryArray[iDict]) delete fDictionaryArray[iDict];
+  if (fGeometry) {
+    delete fGeometry;
+    fGeometry  = 0;
+  }
+  if (fHits) {
+    delete fHits;
+    fHits      = 0;
+  }
+  if (fRecPoints) {
+    delete fRecPoints;
+    fRecPoints = 0;
+  }
+  if (fTrackHits) {
+    delete fTrackHits;
+    fTrackHits = 0;
   }
 
 }
 
 //_____________________________________________________________________________
-void AliTRD::AddCluster(Float_t *pos, Int_t *digits, Int_t det, Float_t amp
-                       , Int_t *tracks, Int_t iType)
+void AliTRD::AddCluster(Float_t *pos, Int_t det, Float_t amp
+                      , Int_t *tracks, Float_t *sig, Int_t iType)
 {
   //
   // Add a cluster for the TRD
   //
 
-  Int_t   pla = fGeometry->GetPlane(det);
-  Int_t   cha = fGeometry->GetChamber(det);
-  Int_t   sec = fGeometry->GetSector(det);
-
-  Float_t padRow  = pos[0]; 
-  Float_t padCol  = pos[1]; 
-  Float_t row0    = fGeometry->GetRow0(pla,cha,sec);
-  Float_t col0    = fGeometry->GetCol0(pla);
-  Float_t rowSize = fGeometry->GetRowPadSize(pla,cha,sec);
-  Float_t colSize = fGeometry->GetColPadSize(pla);
-
   AliTRDcluster *c = new AliTRDcluster();
 
   c->SetDetector(det);
   c->AddTrackIndex(tracks);
-
   c->SetQ(amp);
-
+  c->SetY(pos[0]);
+  c->SetZ(pos[1]);
+  c->SetSigmaY2(sig[0]);   
+  c->SetSigmaZ2(sig[1]);
   c->SetLocalTimeBin(((Int_t) pos[2]));
-  c->SetY(- (col0 + padCol * colSize));
-  c->SetZ(   row0 + padRow * rowSize);
-  
-  c->SetSigmaY2(0.05 * 0.05);
-  c->SetSigmaZ2(rowSize * rowSize / 12.);
 
   switch (iType) {
   case 0:
@@ -326,14 +229,14 @@ void AliTRD::Hits2Digits()
   //
   // Create digits
   //
-
+  if (!fLoader->TreeH()) fLoader->LoadHits("read");
+  SetTreeAddress();
+  
   AliTRDdigitizer *digitizer = new AliTRDdigitizer("TRDdigitizer"
                                                   ,"TRD digitizer class");
-
-  // Set the parameter
-  digitizer->SetDiffusion();
-  digitizer->SetExB();
+  digitizer->SetDebug(GetDebug());
   digitizer->SetEvent(gAlice->GetEvNumber());
+  
   // Initialization
   digitizer->InitDetector();
     
@@ -341,7 +244,9 @@ void AliTRD::Hits2Digits()
   digitizer->MakeDigits();
   
   // Write the digits into the input file
-  if (digitizer->Digits()->MakeBranch(fDigitsFile)) {
+
+  if (!fLoader->TreeD()) fLoader->MakeTree("D");
+  if (digitizer->MakeBranch(fLoader->TreeD())) {
 
     digitizer->WriteDigits();
 
@@ -358,26 +263,27 @@ void AliTRD::Hits2SDigits()
   //
   // Create summable digits
   //
+  if (!fLoader->TreeH()) fLoader->LoadHits("read");
+  SetTreeAddress();
 
   AliTRDdigitizer *digitizer = new AliTRDdigitizer("TRDdigitizer"
                                                   ,"TRD digitizer class");
+  digitizer->SetDebug(GetDebug());
 
   // For the summable digits
   digitizer->SetSDigits(kTRUE);
-
-  // Set the parameter
-  digitizer->SetDiffusion();
-  digitizer->SetExB();
   digitizer->SetEvent(gAlice->GetEvNumber());
 
   // Initialization
   digitizer->InitDetector();
     
-  // Create the digits
+  // Create the TRD s-digits branch
   digitizer->MakeDigits();
   
   // Write the digits into the input file
-  if (digitizer->Digits()->MakeBranch(fDigitsFile)) {
+  if (!fLoader->TreeS()) fLoader->MakeTree("S");
+  
+  if (digitizer->MakeBranch(fLoader->TreeS())) {
 
     digitizer->WriteDigits();
 
@@ -395,29 +301,68 @@ void AliTRD::SDigits2Digits()
   // Create final digits from summable digits
   //
 
-}
+   // Create the TRD digitizer
+  AliTRDdigitizer *digitizer = new AliTRDdigitizer("TRDdigitizer"
+                                                  ,"TRD digitizer class");  
+  digitizer->SetDebug(GetDebug());
 
-//_____________________________________________________________________________
-void AliTRD::AddDigit(Int_t *digits, Int_t *amp)
-{
-  //
-  // Add a digit for the TRD
-  //
+  // Set the parameter
+  digitizer->SetEvent(gAlice->GetEvNumber());
+
+  // Initialization
+  digitizer->InitDetector();
+
+  // Read the s-digits via digits manager
+  AliTRDdigitsManager *sdigitsManager = new AliTRDdigitsManager();
+  sdigitsManager->SetDebug(GetDebug());
+  sdigitsManager->SetSDigits(kTRUE);
+  sdigitsManager->CreateArrays();
+  
+  if (!fLoader->TreeS()) 
+    if (fLoader->LoadSDigits("read"))
+     {
+       Error("SDigits2Digits","Error while reading SDigits for event %d",gAlice->GetEvNumber());
+       return;
+     }
+  if (!fLoader->TreeS()) return;
+  
+  sdigitsManager->ReadDigits(fLoader->TreeS());
 
-  TClonesArray &ldigits = *fDigits;
-  new(ldigits[fNdigits++]) AliTRDdigit(kFALSE,digits,amp);
+  // Add the s-digits to the input list 
+  digitizer->AddSDigitsManager(sdigitsManager);
+
+  // Convert the s-digits to normal digits
+  digitizer->SDigits2Digits();
+
+  // Store the digits
+  if (!fLoader->TreeD()) fLoader->MakeTree("D");
+  if (digitizer->MakeBranch(fLoader->TreeD())){
+    digitizer->WriteDigits();
+  }
 
 }
 
 //_____________________________________________________________________________
-void AliTRD::AddHit(Int_t track, Int_t det, Float_t *hits, Int_t q)
+void AliTRD::AddHit(Int_t track, Int_t det, Float_t *hits, Int_t q
+                  , Bool_t inDrift)
 {
   //
   // Add a hit for the TRD
+  // 
+  // The data structure is set according to fHitType:
+  //   bit0: standard TClonesArray
+  //   bit1: compressed trackHits structure
   //
 
-  TClonesArray &lhits = *fHits;
-  new(lhits[fNhits++]) AliTRDhit(fIshunt,track,det,hits,q);
+  if (fHitType & 1) {
+    TClonesArray &lhits = *fHits;
+    new(lhits[fNhits++]) AliTRDhit(fIshunt,track,det,hits,q);
+  }
+
+  if (fHitType > 1) {
+    AddHit2(track,det,hits,q,inDrift);
+  }
 
 }
 
@@ -463,10 +408,8 @@ void AliTRD::BuildGeometry()
     Float_t slope = (AliTRDgeometry::Zmax1() - AliTRDgeometry::Zmax2())
                   / (AliTRDgeometry::Rmax()  - AliTRDgeometry::Rmin());
 
-    rmin  = AliTRDgeometry::Rmin() + AliTRDgeometry::Ccframe()/2.
-                                   + AliTRDgeometry::DrZpos()
-                                   - AliTRDgeometry::DrThick()/2.;
-    rmax  = rmin + AliTRDgeometry::DrThick();
+    rmin  = AliTRDgeometry::Rmin() + AliTRDgeometry::CraHght();
+    rmax  = rmin                   + AliTRDgeometry::CdrHght();
 
     Float_t thickness = rmin - AliTRDgeometry::Rmin();
     zmax2 = AliTRDgeometry::Zmax2() + slope * thickness;
@@ -539,6 +482,7 @@ void AliTRD::Copy(TObject &trd)
   ((AliTRD &) trd).fFoilDensity = fFoilDensity;
   ((AliTRD &) trd).fDrawTR      = fDrawTR;
   ((AliTRD &) trd).fDisplayType = fDisplayType;
+  ((AliTRD &) trd).fHitType     = fHitType;
 
   //AliDetector::Copy(trd);
 
@@ -632,12 +576,15 @@ void AliTRD::CreateMaterials()
   //     Define Materials 
   //////////////////////////////////////////////////////////////////////////
 
-  AliMaterial( 1, "Al ",  26.98, 13.0, 2.7     ,     8.9 ,    37.2);
-  AliMaterial( 2, "Air",  14.61,  7.3, 0.001205, 30420.0 , 67500.0);
-  AliMaterial( 4, "Xe ", 131.29, 54.0, dxe     ,  1447.59,     0.0);
-  AliMaterial( 5, "Cu ",  63.54, 29.0, 8.96    ,     1.43,    14.8);
-  AliMaterial( 6, "C  ",  12.01,  6.0, 2.265   ,    18.8 ,    74.4);
-  AliMaterial(12, "G10",  20.00, 10.0, 1.7     ,    19.4 ,   999.0);
+  AliMaterial( 1, "Al"   ,  26.98, 13.0, 2.7     ,     8.9 ,    37.2);
+  AliMaterial( 2, "Air"  ,  14.61,  7.3, 0.001205, 30420.0 , 67500.0);
+  AliMaterial( 4, "Xe"   , 131.29, 54.0, dxe     ,  1447.59,     0.0);
+  AliMaterial( 5, "Cu"   ,  63.54, 29.0, 8.96    ,     1.43,    14.8);
+  AliMaterial( 6, "C"    ,  12.01,  6.0, 2.265   ,    18.8 ,    74.4);
+  AliMaterial(12, "G10"  ,  20.00, 10.0, 1.7     ,    19.4 ,   999.0);
+  AliMaterial(15, "Sn"   , 118.71, 50.0, 7.31    ,     1.21,    14.8);
+  AliMaterial(16, "Si"   ,  28.09, 14.0, 2.33    ,     9.36,    37.2);
+  AliMaterial(17, "Epoxy",  17.75,  8.9, 1.8     ,    21.82,   999.0);
 
   // Mixtures 
   AliMixture(3, "Polyethilene",   ape, zpe, dpe, -2, wpe);
@@ -726,6 +673,33 @@ void AliTRD::CreateMaterials()
   // Rohacell (plexiglas) for the radiator
   AliMedium(15, "Rohacell",  14, 0, isxfld, sxmgmx
                 , tmaxfd, stemax, deemax, epsil, stmin);
+  // Al layer in MCMs
+  AliMedium(16, "MCM-Al"  ,   1, 0, isxfld, sxmgmx
+                , tmaxfd, stemax, deemax, epsil, stmin);
+  // Sn layer in MCMs
+  AliMedium(17, "MCM-Sn"  ,  15, 0, isxfld, sxmgmx
+                , tmaxfd, stemax, deemax, epsil, stmin);
+  // Cu layer in MCMs
+  AliMedium(18, "MCM-Cu"  ,   5, 0, isxfld, sxmgmx
+                , tmaxfd, stemax, deemax, epsil, stmin);
+  // G10 layer in MCMs
+  AliMedium(19, "MCM-G10" ,  12, 0, isxfld, sxmgmx
+                , tmaxfd, stemax, deemax, epsil, stmin);
+  // Si in readout chips
+  AliMedium(20, "Chip-Si" ,  16, 0, isxfld, sxmgmx
+                , tmaxfd, stemax, deemax, epsil, stmin);
+  // Epoxy in readout chips
+  AliMedium(21, "Chip-Ep" ,  17, 0, isxfld, sxmgmx
+                , tmaxfd, stemax, deemax, epsil, stmin);
+  // PE in connectors
+  AliMedium(22, "Conn-PE" ,   3, 0, isxfld, sxmgmx
+                , tmaxfd, stemax, deemax, epsil, stmin);
+  // Cu in connectors
+  AliMedium(23, "Chip-Cu" ,   5, 0, isxfld, sxmgmx
+                , tmaxfd, stemax, deemax, epsil, stmin);
+  // Al of cooling pipes
+  AliMedium(24, "Cooling" ,   1, 0, isxfld, sxmgmx
+                , tmaxfd, stemax, deemax, epsil, stmin);
 
   // Save the density values for the TRD absorbtion
   fFoilDensity = dmy;
@@ -737,7 +711,7 @@ void AliTRD::CreateMaterials()
 }
 
 //_____________________________________________________________________________
-void AliTRD::DrawModule()
+void AliTRD::DrawModule() const
 {
   //
   // Draw a shaded view of the Transition Radiation Detector version 0
@@ -758,9 +732,9 @@ void AliTRD::DrawModule()
     gMC->Gsatt("BTR1","SEEN", 0);
     gMC->Gsatt("BTR2","SEEN", 0);
     gMC->Gsatt("BTR3","SEEN", 0);
-    gMC->Gsatt("TRD1","SEEN", 0);
-    gMC->Gsatt("TRD2","SEEN", 0);
-    gMC->Gsatt("TRD3","SEEN", 0);
+    gMC->Gsatt("UTR1","SEEN", 0);
+    gMC->Gsatt("UTR2","SEEN", 0);
+    gMC->Gsatt("UTR3","SEEN", 0);
   }
   else {
     gMC->Gsatt("B071","SEEN", 0);
@@ -770,18 +744,18 @@ void AliTRD::DrawModule()
     gMC->Gsatt("BTR1","SEEN", 0);
     gMC->Gsatt("BTR2","SEEN", 0);
     gMC->Gsatt("BTR3","SEEN", 0);
-    gMC->Gsatt("TRD1","SEEN", 0);
+    gMC->Gsatt("UTR1","SEEN", 0);
     if (fGeometry->GetPHOShole())
-      gMC->Gsatt("TRD2","SEEN", 0);
+      gMC->Gsatt("UTR2","SEEN", 0);
     if (fGeometry->GetRICHhole())
-      gMC->Gsatt("TRD3","SEEN", 0);
+      gMC->Gsatt("UTR3","SEEN", 0);
   }
-  gMC->Gsatt("UCII","SEEN", 0);
-  gMC->Gsatt("UCIM","SEEN", 0);
-  gMC->Gsatt("UCIO","SEEN", 0);
-  gMC->Gsatt("UL02","SEEN", 1);
-  gMC->Gsatt("UL05","SEEN", 1);
-  gMC->Gsatt("UL06","SEEN", 1);
+//   gMC->Gsatt("UCII","SEEN", 0);
+//   gMC->Gsatt("UCIM","SEEN", 0);
+//   gMC->Gsatt("UCIO","SEEN", 0);
+//   gMC->Gsatt("UL02","SEEN", 1);
+//   gMC->Gsatt("UL05","SEEN", 1);
+//   gMC->Gsatt("UL06","SEEN", 1);
   
   gMC->Gdopt("hide", "on");
   gMC->Gdopt("shad", "on");
@@ -796,7 +770,7 @@ void AliTRD::DrawModule()
 }
 
 //_____________________________________________________________________________
-Int_t AliTRD::DistancetoPrimitive(Int_t , Int_t )
+Int_t AliTRD::DistancetoPrimitive(Int_t , Int_t ) const
 {
   //
   // Distance between the mouse and the TRD detector on the screen
@@ -815,7 +789,7 @@ void AliTRD::Init()
 
   Int_t i;
 
-  if(fDebug) {
+  if (fDebug) {
     printf("\n%s: ",ClassName());
     for (i = 0; i < 35; i++) printf("*");
     printf(" TRD_INIT ");
@@ -834,10 +808,12 @@ void AliTRD::Init()
       printf("%s: Leave space in front of RICH free\n",ClassName());
   }
   
-  if (fGasMix == 1)
+  if (fGasMix == 1) {
     printf("%s: Gas Mixture: 85%% Xe + 15%% CO2\n",ClassName());
-  else
+  }
+  else {
     printf("%s: Gas Mixture: 97%% Xe + 3%% Isobutane\n",ClassName());
+  }
 
 }
 
@@ -849,14 +825,20 @@ void AliTRD::LoadPoints(Int_t track)
   // Hit originating from TR photons are given a different color
   //
 
-  if (!fDrawTR) {
-    AliDetector::LoadPoints(track);
-    return;
-  }
+  //if (!fDrawTR) {
+  //  AliDetector::LoadPoints(track);
+  //  return;
+  //}
 
-  if (fHits == 0) return;
+  if ((fHits == 0) && (fTrackHits == 0)) return;
 
-  Int_t nhits  = fHits->GetEntriesFast();
+  Int_t nhits;
+  if (fHitType < 2) {
+    nhits = fHits->GetEntriesFast();
+  }
+  else {
+    nhits = fTrackHits->GetEntriesFast();
+  } 
   if (nhits == 0) return;
 
   Int_t tracks = gAlice->GetNtrack();
@@ -879,18 +861,17 @@ void AliTRD::LoadPoints(Int_t track)
     limiT[i] = 0;
   }
   
-  AliTRDpoints  *points = 0;
-  Float_t       *fp     = 0;
-  Int_t          trk;
-  Int_t          chunk  = nhits / 4 + 1;
+  AliTRDpoints *points = 0;
+  Float_t      *fp     = 0;
+  Int_t         trk;
+  Int_t         chunk  = nhits / 4 + 1;
 
   // Loop over all the hits and store their position
-  for (Int_t hit = 0; hit < nhits; hit++) {
-
-    ahit = (AliTRDhit *) fHits->UncheckedAt(hit);
+  ahit = (AliTRDhit *) FirstHit(-1);
+  while (ahit) {
 
     // dEdx hits
-    if (ahit->FromDrift() || ahit->FromAmplification()) {
+    if (ahit->GetCharge() >= 0) {
 
       trk = ahit->GetTrack();
       if (ntrkE[trk] == limiE[trk]) {
@@ -913,7 +894,7 @@ void AliTRD::LoadPoints(Int_t track)
 
     }
     // TR photon hits
-    else if (ahit->FromTRphoton()) {
+    else if ((ahit->GetCharge() < 0) && (fDrawTR)) {
 
       trk = ahit->GetTrack();
       if (ntrkT[trk] == limiT[trk]) {
@@ -936,6 +917,8 @@ void AliTRD::LoadPoints(Int_t track)
 
     }
 
+    ahit = (AliTRDhit *) NextHit();
+
   }
 
   for (trk = 0; trk < tracks; ++trk) {
@@ -978,54 +961,39 @@ void AliTRD::LoadPoints(Int_t track)
 }
 
 //_____________________________________________________________________________
-void AliTRD::MakeBranch(Option_t* option, const char *file)
+void AliTRD::MakeBranch(Option_t* option)
 {
   //
-  // Create Tree branches for the TRD digits and cluster.
+  // Create Tree branches for the TRD digits.
   //
 
-  //Int_t  buffersize = 4000;
-  //Char_t branchname[15];
+  Int_t  buffersize = 4000;
+  Char_t branchname[15];
+  sprintf(branchname,"%s",GetName());
 
-  AliDetector::MakeBranch(option,file);
+  const char *cD = strstr(option,"D");
 
-  Int_t buffersize = 64000;
+  AliDetector::MakeBranch(option);
 
-  fDigitsArray = new AliTRDdataArrayI();
-  MakeBranchInTree(gAlice->TreeD() 
-                   ,"TRDdigits", fDigitsArray->IsA()->GetName()
-                   ,&fDigitsArray,buffersize,1,file);
+  if (fDigits && gAlice->TreeD() && cD) {
+    MakeBranchInTree(gAlice->TreeD(),branchname,&fDigits,buffersize,0);
+  }    
 
-  for (Int_t iDict = 0; iDict < AliTRDdigitsManager::NDict(); iDict++) {
-    Char_t branchname[15];
-    sprintf(branchname,"TRDdictionary%d",iDict);
-    fDictionaryArray[iDict] = new AliTRDdataArrayI();
-    MakeBranchInTree(gAlice->TreeD() 
-                     ,branchname,fDictionaryArray[iDict]->IsA()->GetName()
-                     ,&fDictionaryArray[iDict],buffersize,1,file);
+  if (fHitType > 1) {
+    MakeBranch2(option,0); 
   }
+
 }
 
 //_____________________________________________________________________________
 void AliTRD::ResetDigits()
 {
   //
-  // Resets the digits
+  // Reset number of digits and the digits array for this detector
   //
 
-  if (gAlice->TreeD()) {
-    TBranch *branch;
-    branch = gAlice->TreeD()->GetBranch("TRDdigits");
-    if (branch) {
-      branch->Reset();
-      for (Int_t iDict = 0; iDict < AliTRDdigitsManager::NDict(); iDict++) {
-        Char_t branchname[15];
-        sprintf(branchname,"TRDdictionary%d",iDict);
-        branch = gAlice->TreeD()->GetBranch(branchname);
-        branch->Reset();
-      }
-    }
-  }
+  fNdigits = 0;
+  if (fDigits) fDigits->Clear();
 
 }
 
@@ -1053,13 +1021,15 @@ void AliTRD::SetTreeAddress()
 
   Char_t branchname[15];
 
+  if ( fLoader->TreeH() && (fHits == 0x0))  fHits = new TClonesArray("AliTRDhit",405);
   AliDetector::SetTreeAddress();
 
   TBranch *branch;
-  TTree   *treeR = gAlice->TreeR();
+  TTree   *treeR = fLoader->TreeR();
 
   if (treeR) {
     sprintf(branchname,"%scluster",GetName());
+    if (fRecPoints == 0x0) fRecPoints  = new TObjArray(400);
     if (fRecPoints) {
       branch = treeR->GetBranch(branchname);
       if (branch) {
@@ -1068,6 +1038,10 @@ void AliTRD::SetTreeAddress()
     }
   }
 
+  if (fHitType > 0) {
+    SetTreeAddress2();    
+  }
+
 }
 
 //_____________________________________________________________________________
@@ -1121,3 +1095,550 @@ AliTRD &AliTRD::operator=(const AliTRD &trd)
   return *this;
 
 } 
+
+//_____________________________________________________________________________
+void AliTRD::FinishPrimary()
+{
+  //
+  // Store the hits in the containers after all primaries are finished
+  //
+
+  if (fTrackHits) { 
+    fTrackHits->FlushHitStack();
+  }
+
+}
+
+//_____________________________________________________________________________
+void AliTRD::RemapTrackHitIDs(Int_t *map)
+{
+  //
+  // Remap the track IDs
+  //
+
+  if (!fTrackHits) {
+    return;
+  }
+
+  if (fTrackHits) {
+    TClonesArray *arr = fTrackHits->GetArray();;
+    for (Int_t i = 0; i < arr->GetEntriesFast(); i++){
+      AliTrackHitsParamV2 *info = (AliTrackHitsParamV2 *) (arr->At(i));
+      info->fTrackID = map[info->fTrackID];
+    }
+  }
+
+}
+
+//_____________________________________________________________________________
+void AliTRD::ResetHits()
+{
+  //
+  // Reset the hits
+  //
+
+  AliDetector::ResetHits();
+  if (fTrackHits) {
+    fTrackHits->Clear();
+  }
+
+}
+
+//_____________________________________________________________________________
+AliHit* AliTRD::FirstHit(Int_t track)
+{
+  //
+  // Return the first hit of a track
+  //
+
+  if (fHitType > 1) {
+    return FirstHit2(track);
+  }
+
+  return AliDetector::FirstHit(track);
+
+}
+
+//_____________________________________________________________________________
+AliHit* AliTRD::NextHit()
+{
+  //
+  // Returns the next hit of a track
+  //
+
+  if (fHitType > 1) {
+    return NextHit2();
+  }
+
+  return AliDetector::NextHit();
+
+}
+
+//_____________________________________________________________________________
+AliHit* AliTRD::FirstHit2(Int_t track) 
+{
+  //
+  // Initializes the hit iterator.
+  // Returns the address of the first hit of a track.
+  // If <track> >= 0 the track is read from disk,
+  // while if <track> < 0 the first hit of the current
+  // track is returned.
+  //
+
+  if (track >= 0) {
+    gAlice->ResetHits();
+    TreeH()->GetEvent(track);
+  }
+  
+  if (fTrackHits) {
+    fTrackHits->First();
+    return (AliHit*) fTrackHits->GetHit();
+  }
+  else {
+    return 0;
+  }
+
+}
+
+//_____________________________________________________________________________
+AliHit* AliTRD::NextHit2()
+{
+  //
+  // Returns the next hit of the current track
+  //
+
+  if (fTrackHits) {
+    fTrackHits->Next();
+    return (AliHit *) fTrackHits->GetHit();
+  }
+  else {
+    return 0;
+  }
+
+}
+
+//_____________________________________________________________________________
+void AliTRD::MakeBranch2(Option_t *option, const char *file)
+{
+  //
+  // Create a new branch in the current Root tree.
+  // The branch of fHits is automatically split.
+  //
+
+  if (fHitType < 2) {
+    return;
+  }
+
+  char branchname[10];
+  sprintf(branchname,"%s2",GetName());
+
+  // Get the pointer to the header
+  const char *cH = strstr(option,"H");
+  if (!fTrackHits) {
+    fTrackHits = new AliTRDtrackHits();
+   }
+
+
+  if (fTrackHits && TreeH() && cH) 
+   {
+    TreeH()->Branch(branchname,"AliTRDtrackHits",&fTrackHits,fBufferSize,99);
+    Info("MakeBranch2","Making Branch %s for trackhits",branchname);
+   }
+}
+
+//_____________________________________________________________________________
+void AliTRD::SetTreeAddress2()
+{
+  //
+  // Set the branch address for the trackHits tree
+  //
+  cout<<"AliTRD::SetTreeAddress2()"<<endl;
+
+  TBranch *branch;
+  char branchname[20];
+  sprintf(branchname,"%s2",GetName());
+  
+  // Branch address for hit tree
+  TTree *treeH = TreeH();
+  if ((treeH) && (fHitType > 0)) {
+    branch = treeH->GetBranch(branchname);
+    if (branch) 
+     {
+       branch->SetAddress(&fTrackHits);
+       cout<<"Success"<<endl;
+     }
+    else
+     {
+       cout<<"!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"<<endl;
+       cout<<"AliTRD::SetTreeAddress2() Can NOT get the branch "<<branchname<<endl;
+       cout<<"!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"<<endl;
+     }
+  }
+
+}
+
+//_____________________________________________________________________________
+void AliTRD::AddHit2(Int_t track, Int_t det, Float_t *hits, Int_t q
+                   , Bool_t inDrift)
+{
+  //
+  // Add a hit to the list
+  //
+
+  Int_t rtrack;
+
+  if (fIshunt) {
+    Int_t primary = gAlice->GetPrimary(track);
+    gAlice->Particle(primary)->SetBit(kKeepBit);
+    rtrack = primary;
+  } 
+  else {
+    rtrack = track;
+    gAlice->FlagTrack(track);
+  }
+
+  if ((fTrackHits) && (fHitType > 0)) {
+    fTrackHits->AddHitTRD(det,rtrack,hits[0],hits[1],hits[2],q,inDrift);
+  }
+
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+