Adding track references at decay points (M.Ivanov)
[u/mrichter/AliRoot.git] / STEER / AliModule.cxx
index a9531f1..3e90897 100644 (file)
@@ -13,9 +13,7 @@
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
 
-/*
-$Log$
-*/
+/* $Id$ */
 
 ///////////////////////////////////////////////////////////////////////////////
 //                                                                           //
@@ -34,41 +32,68 @@ $Log$
 //End_Html
 //                                                                           //
 ///////////////////////////////////////////////////////////////////////////////
+
+#include <TNode.h>
+#include <TObjArray.h>
+#include <TClonesArray.h>
+#include <TTree.h>
+#include <TSystem.h>
+#include <TDirectory.h>
+
+#include "AliConfig.h"
+#include "AliLoader.h"
+#include "AliMagF.h"
 #include "AliModule.h"
 #include "AliRun.h"
-#include "AliHit.h"
-#include "AliPoints.h"
-#include <TClass.h>
-#include <TNode.h>
-#include <TRandom.h>
+#include "AliTrackReference.h"
 
 ClassImp(AliModule)
  
-//_____________________________________________________________________________
-AliModule::AliModule()
+//_______________________________________________________________________
+AliModule::AliModule():
+  fEuclidMaterial(""),
+  fEuclidGeometry(""),
+  fIdtmed(0),
+  fIdmate(0),
+  fLoMedium(0),
+  fHiMedium(0),
+  fActive(0),
+  fHistograms(0),
+  fNodes(0),
+  fDebug(0),
+  fEnable(1),
+  fTrackReferences(0),
+  fMaxIterTrackRef(0),
+  fCurrentIterTrackRef(0)
 {
   //
   // Default constructor for the AliModule class
   //
-  fHistograms = 0;
-  fNodes      = 0;
 }
  
-//_____________________________________________________________________________
-AliModule::AliModule(const char* name,const char *title):TNamed(name,title)
+//_______________________________________________________________________
+AliModule::AliModule(const char* name,const char *title):
+  TNamed(name,title),
+  fEuclidMaterial(""),
+  fEuclidGeometry(""),
+  fIdtmed(new TArrayI(100)),
+  fIdmate(new TArrayI(100)),
+  fLoMedium(65536),
+  fHiMedium(0),
+  fActive(0),
+  fHistograms(new TList()),
+  fNodes(new TList()),
+  fDebug(0),
+  fEnable(1),
+  fTrackReferences(new TClonesArray("AliTrackReference", 100)),
+  fMaxIterTrackRef(0),
+  fCurrentIterTrackRef(0)
 {
   //
   // Normal constructor invoked by all Modules.
   // Create the list for Module specific histograms
   // Add this Module to the global list of Modules in Run.
   //
-  //
-  // Initialises the histogram list
-  fHistograms = new TList();
-  //
-  // Initialises the list of ROOT TNodes
-  fNodes      = new TList();
-  //  
   // Get the Module numeric ID
   Int_t id = gAlice->GetModuleID(name);
   if (id>=0) {
@@ -78,39 +103,92 @@ AliModule::AliModule(const char* name,const char *title):TNamed(name,title)
   }
   //
   // Add this Module to the list of Modules
-  gAlice->Modules()->Add(this);
-  //
-  //
+
+  gAlice->AddModule(this);
+
   SetMarkerColor(3);
   //
-  // Allocate space for tracking media and material indexes
-  fIdtmed = new TArrayI(100);
-  fIdmate  = new TArrayI(100);
+  // Clear space for tracking media and material indexes
+
   for(Int_t i=0;i<100;i++) (*fIdmate)[i]=(*fIdtmed)[i]=0;
-  //
-  // Prepare to find the tracking media range
-  fLoMedium = 65536;
-  fHiMedium = 0;
+
+    
+  SetDebug(gAlice->GetDebug());
 }
  
-//_____________________________________________________________________________
+//_______________________________________________________________________
+AliModule::AliModule(const AliModule &mod):
+  TNamed(mod),
+  TAttLine(mod),
+  TAttMarker(mod),
+  AliRndm(mod),
+  fEuclidMaterial(""),
+  fEuclidGeometry(""),
+  fIdtmed(0),
+  fIdmate(0),
+  fLoMedium(0),
+  fHiMedium(0),
+  fActive(0),
+  fHistograms(0),
+  fNodes(0),
+  fDebug(0),
+  fEnable(0),
+  fTrackReferences(0),
+  fMaxIterTrackRef(0),
+  fCurrentIterTrackRef(0)
+{
+  //
+  // Copy constructor
+  //
+  mod.Copy(*this);
+}
+
+//_______________________________________________________________________
 AliModule::~AliModule()
 {
   //
   // Destructor
   //
-  fHistograms = 0;
-  //
+
+  // Remove this Module from the list of Modules
+  if (gAlice) {
+    TObjArray * modules = gAlice->Modules();
+    if (modules) modules->Remove(this);
+  }
   // Delete ROOT geometry
-  fNodes->Clear();
-  delete fNodes;
-  //
+  if(fNodes) {
+    fNodes->Clear();
+    delete fNodes;
+    fNodes = 0;
+  }
+  // Delete histograms
+  if(fHistograms) {
+    fHistograms->Clear();
+    delete fHistograms;
+    fHistograms = 0;
+  }
+  // Delete track references
+  if (fTrackReferences) {
+    fTrackReferences->Delete();
+    delete fTrackReferences;
+    fTrackReferences     = 0;
+  }
   // Delete TArray objects
   delete fIdtmed;
   delete fIdmate;
+
 }
  
-//_____________________________________________________________________________
+//_______________________________________________________________________
+void AliModule::Copy(AliModule & /* mod */) const
+{
+  //
+  // Copy *this onto mod, not implemented for AliModule
+  //
+  Fatal("Copy","Not implemented!\n");
+}
+
+//_______________________________________________________________________
 void AliModule::Disable()
 {
   //
@@ -122,13 +200,13 @@ void AliModule::Disable()
   //
   // Loop through geometry to disable all
   // nodes for this Module
-  while((node = (TNode*)next())) {
-    node->SetVisibility(0);
+  while((node = dynamic_cast<TNode*>(next()))) {
+    node->SetVisibility(-1);
   }   
 }
 
-//_____________________________________________________________________________
-Int_t AliModule::DistancetoPrimitive(Int_t, Int_t)
+//_______________________________________________________________________
+Int_t AliModule::DistancetoPrimitive(Int_t, Int_t) const
 {
   //
   // Return distance from mouse pointer to object
@@ -137,7 +215,7 @@ Int_t AliModule::DistancetoPrimitive(Int_t, Int_t)
   return 9999;
 }
 
-//_____________________________________________________________________________
+//_______________________________________________________________________
 void AliModule::Enable()
 {
   //
@@ -149,15 +227,15 @@ void AliModule::Enable()
   //
   // Loop through geometry to enable all
   // nodes for this Module
-  while((node = (TNode*)next())) {
-    node->SetVisibility(1);
+  while((node = dynamic_cast<TNode*>(next()))) {
+    node->SetVisibility(3);
   }   
 }
 
-//_____________________________________________________________________________
+//_______________________________________________________________________
 void AliModule::AliMaterial(Int_t imat, const char* name, Float_t a, 
-                             Float_t z, Float_t dens, Float_t radl,
-                             Float_t absl, Float_t *buf, Int_t nwbuf) const
+                            Float_t z, Float_t dens, Float_t radl,
+                            Float_t absl, Float_t *buf, Int_t nwbuf) const
 {
   //
   // Store the parameters for a material
@@ -177,10 +255,10 @@ void AliModule::AliMaterial(Int_t imat, const char* name, Float_t a,
   (*fIdmate)[imat]=kmat;
 }
   
-//_____________________________________________________________________________
+//_______________________________________________________________________
 void AliModule::AliGetMaterial(Int_t imat, char* name, Float_t &a, 
-                             Float_t &z, Float_t &dens, Float_t &radl,
-                             Float_t &absl)
+                               Float_t &z, Float_t &dens, Float_t &radl,
+                               Float_t &absl) const
 {
   //
   // Store the parameters for a material
@@ -203,10 +281,10 @@ void AliModule::AliGetMaterial(Int_t imat, char* name, Float_t &a,
 }
   
 
-//_____________________________________________________________________________
+//_______________________________________________________________________
 void AliModule::AliMixture(Int_t imat, const char *name, Float_t *a,
-                            Float_t *z, Float_t dens, Int_t nlmat,
-                            Float_t *wmat) const
+                           Float_t *z, Float_t dens, Int_t nlmat,
+                           Float_t *wmat) const
 { 
   //
   // Defines mixture or compound imat as composed by 
@@ -232,17 +310,17 @@ void AliModule::AliMixture(Int_t imat, const char *name, Float_t *a,
   (*fIdmate)[imat]=kmat;
 } 
  
-//_____________________________________________________________________________
+//_______________________________________________________________________
 void AliModule::AliMedium(Int_t numed, const char *name, Int_t nmat,
-                           Int_t isvol, Int_t ifield, Float_t fieldm,
-                           Float_t tmaxfd, Float_t stemax, Float_t deemax,
-                           Float_t epsil, Float_t stmin, Float_t *ubuf,
-                           Int_t nbuf) const
+                          Int_t isvol, Int_t ifield, Float_t fieldm,
+                          Float_t tmaxfd, Float_t stemax, Float_t deemax,
+                          Float_t epsil, Float_t stmin, Float_t *ubuf,
+                          Int_t nbuf) const
 { 
   //
   // Store the parameters of a tracking medium
   //
-  // numed       the medium number is stored into (*fIdtmed)[numed-1]
+  // numed       the medium number is stored into (*fIdtmed)[numed]
   // name        medium name
   // nmat        the material number is stored into (*fIdmate)[nmat]
   // isvol       sensitive volume if isvol!=0
@@ -266,10 +344,10 @@ void AliModule::AliMedium(Int_t numed, const char *name, Int_t nmat,
   (*fIdtmed)[numed]=kmed;
 } 
  
-//_____________________________________________________________________________
+//_______________________________________________________________________
 void AliModule::AliMatrix(Int_t &nmat, Float_t theta1, Float_t phi1,
-                           Float_t theta2, Float_t phi2, Float_t theta3,
-                           Float_t phi3) const
+                          Float_t theta2, Float_t phi2, Float_t theta3,
+                          Float_t phi3) const
 {
   // 
   // Define a rotation matrix. Angles are in degrees.
@@ -285,7 +363,19 @@ void AliModule::AliMatrix(Int_t &nmat, Float_t theta1, Float_t phi1,
   gMC->Matrix(nmat, theta1, phi1, theta2, phi2, theta3, phi3); 
 } 
 
-//_____________________________________________________________________________
+//_______________________________________________________________________
+Float_t AliModule::ZMin() const
+{
+  return -500;
+}
+
+//_______________________________________________________________________
+Float_t AliModule::ZMax() const
+{
+  return 500;
+}
+
+//_______________________________________________________________________
 void AliModule::SetEuclidFile(char* material, char* geometry)
 {
   //
@@ -303,36 +393,445 @@ void AliModule::SetEuclidFile(char* material, char* geometry)
   }
 }
  
-//_____________________________________________________________________________
-void AliModule::Streamer(TBuffer &R__b)
+//_______________________________________________________________________
+void AliModule::ReadEuclid(const char* filnam, char* topvol)
 {
+  //                                                                     
+  //       read in the geometry of the detector in euclid file format    
+  //                                                                     
+  //        id_det : the detector identification (2=its,...)            
+  //        topvol : return parameter describing the name of the top    
+  //        volume of geometry.                                          
+  //                                                                     
+  //            author : m. maire                                        
+  //                                                                     
+  //     28.07.98
+  //     several changes have been made by miroslav helbich
+  //     subroutine is rewrited to follow the new established way of memory
+  //     booking for tracking medias and rotation matrices.
+  //     all used tracking media have to be defined first, for this you can use
+  //     subroutine  greutmed.
+  //     top volume is searched as only volume not positioned into another 
   //
-  // Stream an object of class Module.
-  //
-  if (R__b.IsReading()) {
-    Version_t R__v = R__b.ReadVersion(); if (R__v) { }
-    TNamed::Streamer(R__b);
-    TAttLine::Streamer(R__b);
-    TAttMarker::Streamer(R__b);
-    fEuclidMaterial.Streamer(R__b);
-    fEuclidGeometry.Streamer(R__b);
-    R__b >> fActive;
-    R__b >> fHistograms;
+
+  Int_t i, nvol, iret, itmed, irot, numed, npar, ndiv, iaxe;
+  Int_t ndvmx, nr, flag;
+  char key[5], card[77], natmed[21];
+  char name[5], mother[5], shape[5], konly[5], volst[7000][5];
+  char *filtmp;
+  Float_t par[100];
+  Float_t teta1, phi1, teta2, phi2, teta3, phi3, orig, step;
+  Float_t xo, yo, zo;
+  const Int_t kMaxRot=5000;
+  Int_t idrot[kMaxRot],istop[7000];
+  FILE *lun;
+  //
+  // *** The input filnam name will be with extension '.euc'
+  filtmp=gSystem->ExpandPathName(filnam);
+  lun=fopen(filtmp,"r");
+  delete [] filtmp;
+  if(!lun) {
+    Error("ReadEuclid","Could not open file %s\n",filnam);
+    return;
+  }
+  //* --- definition of rotation matrix 0 ---  
+  TArrayI &idtmed = *fIdtmed;
+  for(i=1; i<kMaxRot; ++i) idrot[i]=-99;
+  idrot[0]=0;
+  nvol=0;
+ L10:
+  for(i=0;i<77;i++) card[i]=0;
+  iret=fscanf(lun,"%77[^\n]",card);
+  if(iret<=0) goto L20;
+  fscanf(lun,"%*c");
+  //*
+  strncpy(key,card,4);
+  key[4]='\0';
+  if (!strcmp(key,"TMED")) {
+    sscanf(&card[5],"%d '%[^']'",&itmed,natmed);
+    if( itmed<0 || itmed>=100 ) {
+      Error("ReadEuclid","TMED illegal medium number %d for %s\n",itmed,natmed);
+      exit(1);
+    }
+    //Pad the string with blanks
+    i=-1;
+    while(natmed[++i]);
+    while(i<20) natmed[i++]=' ';
+    natmed[i]='\0';
     //
-    // Stream the pointers but not the TClonesArrays
-    R__b >> fNodes; // diff
-  } else {
-    R__b.WriteVersion(AliModule::IsA());
-    TNamed::Streamer(R__b);
-    TAttLine::Streamer(R__b);
-    TAttMarker::Streamer(R__b);
-    fEuclidMaterial.Streamer(R__b);
-    fEuclidGeometry.Streamer(R__b);
-    R__b << fActive;
-    R__b << fHistograms;
+    if( idtmed[itmed]<=0 ) {
+      Error("ReadEuclid","TMED undefined medium number %d for %s\n",itmed,natmed);
+      exit(1);
+    }
+    gMC->Gckmat(idtmed[itmed],natmed);
+    //*
+  } else if (!strcmp(key,"ROTM")) {
+    sscanf(&card[4],"%d %f %f %f %f %f %f",&irot,&teta1,&phi1,&teta2,&phi2,&teta3,&phi3);
+    if( irot<=0 || irot>=kMaxRot ) {
+      Error("ReadEuclid","ROTM rotation matrix number %d illegal\n",irot);
+      exit(1);
+    }
+    AliMatrix(idrot[irot],teta1,phi1,teta2,phi2,teta3,phi3);
+    //*
+  } else if (!strcmp(key,"VOLU")) {
+    sscanf(&card[5],"'%[^']' '%[^']' %d %d", name, shape, &numed, &npar);
+    if (npar>0) {
+      for(i=0;i<npar;i++) fscanf(lun,"%f",&par[i]);
+      fscanf(lun,"%*c");
+    }
+    gMC->Gsvolu( name, shape, idtmed[numed], par, npar);
+    //*     save the defined volumes
+    strcpy(volst[++nvol],name);
+    istop[nvol]=1;
+    //*
+  } else if (!strcmp(key,"DIVN")) {
+    sscanf(&card[5],"'%[^']' '%[^']' %d %d", name, mother, &ndiv, &iaxe);
+    gMC->Gsdvn  ( name, mother, ndiv, iaxe );
+    //*
+  } else if (!strcmp(key,"DVN2")) {
+    sscanf(&card[5],"'%[^']' '%[^']' %d %d %f %d",name, mother, &ndiv, &iaxe, &orig, &numed);
+    gMC->Gsdvn2( name, mother, ndiv, iaxe, orig,idtmed[numed]);
+    //*
+  } else if (!strcmp(key,"DIVT")) {
+    sscanf(&card[5],"'%[^']' '%[^']' %f %d %d %d", name, mother, &step, &iaxe, &numed, &ndvmx);
+    gMC->Gsdvt ( name, mother, step, iaxe, idtmed[numed], ndvmx);
+    //*
+  } else if (!strcmp(key,"DVT2")) {
+    sscanf(&card[5],"'%[^']' '%[^']' %f %d %f %d %d", name, mother, &step, &iaxe, &orig, &numed, &ndvmx);
+    gMC->Gsdvt2 ( name, mother, step, iaxe, orig, idtmed[numed], ndvmx );
+    //*
+  } else if (!strcmp(key,"POSI")) {
+    sscanf(&card[5],"'%[^']' %d '%[^']' %f %f %f %d '%[^']'", name, &nr, mother, &xo, &yo, &zo, &irot, konly);
+    if( irot<0 || irot>=kMaxRot ) {
+      Error("ReadEuclid","POSI %s#%d rotation matrix number %d illegal\n",name,nr,irot);
+      exit(1);
+    }
+    if( idrot[irot] == -99) {
+      Error("ReadEuclid","POSI %s#%d undefined matrix number %d\n",name,nr,irot);
+      exit(1);
+    }
+    //*** volume name cannot be the top volume
+    for(i=1;i<=nvol;i++) {
+      if (!strcmp(volst[i],name)) istop[i]=0;
+    }
+    //*
+    gMC->Gspos  ( name, nr, mother, xo, yo, zo, idrot[irot], konly );
+    //*
+  } else if (!strcmp(key,"POSP")) {
+    sscanf(&card[5],"'%[^']' %d '%[^']' %f %f %f %d '%[^']' %d", name, &nr, mother, &xo, &yo, &zo, &irot, konly, &npar);
+    if( irot<0 || irot>=kMaxRot ) {
+      Error("ReadEuclid","POSP %s#%d rotation matrix number %d illegal\n",name,nr,irot);
+      exit(1);
+    }
+    if( idrot[irot] == -99) {
+      Error("ReadEuclid","POSP %s#%d undefined matrix number %d\n",name,nr,irot);
+      exit(1);
+    }
+    if (npar > 0) {
+      for(i=0;i<npar;i++) fscanf(lun,"%f",&par[i]);
+      fscanf(lun,"%*c");
+    }
+    //*** volume name cannot be the top volume
+    for(i=1;i<=nvol;i++) {
+      if (!strcmp(volst[i],name)) istop[i]=0;
+    }
+    //*
+    gMC->Gsposp ( name, nr, mother, xo,yo,zo, idrot[irot], konly, par, npar);
+  }
+  //*
+  if (strcmp(key,"END")) goto L10;
+  //* find top volume in the geometry
+  flag=0;
+  for(i=1;i<=nvol;i++) {
+    if (istop[i] && flag) {
+      Warning("ReadEuclid"," %s is another possible top volume\n",volst[i]);
+    }
+    if (istop[i] && !flag) {
+      strcpy(topvol,volst[i]);
+      if(fDebug) printf("%s::ReadEuclid: volume %s taken as a top volume\n",ClassName(),topvol);
+      flag=1;
+    }
+  }
+  if (!flag) {
+    Warning("ReadEuclid","top volume not found\n");
+  }
+  fclose (lun);
+  //*
+  //*     commented out only for the not cernlib version
+  if(fDebug) printf("%s::ReadEuclid: file: %s is now read in\n",ClassName(),filnam);
+  //
+  return;
+  //*
+  L20:
+  Error("ReadEuclid","reading error or premature end of file\n");
+}
+
+//_______________________________________________________________________
+void AliModule::ReadEuclidMedia(const char* filnam)
+{
+  //                                                                     
+  //       read in the materials and tracking media for the detector     
+  //                   in euclid file format                             
+  //                                                                     
+  //       filnam: name of the input file                                
+  //       id_det: id_det is the detector identification (2=its,...)     
+  //                                                                     
+  //            author : miroslav helbich                                
+  //
+  Float_t sxmgmx = gAlice->Field()->Max();
+  Int_t   isxfld = gAlice->Field()->Integ();
+  Int_t end, i, iret, itmed;
+  char key[5], card[130], natmed[21], namate[21];
+  Float_t ubuf[50];
+  char* filtmp;
+  FILE *lun;
+  Int_t imate;
+  Int_t nwbuf, isvol, ifield, nmat;
+  Float_t a, z, dens, radl, absl, fieldm, tmaxfd, stemax, deemax, epsil, stmin;
+  //
+  end=strlen(filnam);
+  for(i=0;i<end;i++) if(filnam[i]=='.') {
+    end=i;
+    break;
+  }
+  //
+  // *** The input filnam name will be with extension '.euc'
+  if(fDebug) printf("%s::ReadEuclid: The file name is %s\n",ClassName(),filnam); //Debug
+  filtmp=gSystem->ExpandPathName(filnam);
+  lun=fopen(filtmp,"r");
+  delete [] filtmp;
+  if(!lun) {
+    Warning("ReadEuclidMedia","Could not open file %s\n",filnam);
+    return;
+  }
+  //
+  // Retrieve Mag Field parameters
+  Int_t globField=gAlice->Field()->Integ();
+  Float_t globMaxField=gAlice->Field()->Max();
+  //  TArrayI &idtmed = *fIdtmed;
+  //
+ L10:
+  for(i=0;i<130;i++) card[i]=0;
+  iret=fscanf(lun,"%4s %[^\n]",key,card);
+  if(iret<=0) goto L20;
+  fscanf(lun,"%*c");
+  //*
+  //* read material
+  if (!strcmp(key,"MATE")) {
+    sscanf(card,"%d '%[^']' %f %f %f %f %f %d",&imate,namate,&a,&z,&dens,&radl,&absl,&nwbuf);
+    if (nwbuf>0) for(i=0;i<nwbuf;i++) fscanf(lun,"%f",&ubuf[i]);
+    //Pad the string with blanks
+    i=-1;
+    while(namate[++i]);
+    while(i<20) namate[i++]=' ';
+    namate[i]='\0';
     //
-    // Stream the pointers but not the TClonesArrays
-    R__b << fNodes; // diff
+    AliMaterial(imate,namate,a,z,dens,radl,absl,ubuf,nwbuf);
+    //* read tracking medium
+  } else if (!strcmp(key,"TMED")) {
+    sscanf(card,"%d '%[^']' %d %d %d %f %f %f %f %f %f %d",
+          &itmed,natmed,&nmat,&isvol,&ifield,&fieldm,&tmaxfd,
+          &stemax,&deemax,&epsil,&stmin,&nwbuf);
+    if (nwbuf>0) for(i=0;i<nwbuf;i++) fscanf(lun,"%f",&ubuf[i]);
+    if (ifield<0) ifield=isxfld;
+    if (fieldm<0) fieldm=sxmgmx;
+    //Pad the string with blanks
+    i=-1;
+    while(natmed[++i]);
+    while(i<20) natmed[i++]=' ';
+    natmed[i]='\0';
+    //
+    AliMedium(itmed,natmed,nmat,isvol,globField,globMaxField,tmaxfd,
+                  stemax,deemax,epsil,stmin,ubuf,nwbuf);
+    //    (*fImedia)[idtmed[itmed]-1]=id_det;
+    //*
+  }
+  //*
+  if (strcmp(key,"END")) goto L10;
+  fclose (lun);
+  //*
+  //*     commented out only for the not cernlib version
+  if(fDebug) printf("%s::ReadEuclidMedia: file %s is now read in\n",
+       ClassName(),filnam);
+  //*
+  return;
+  //*
+ L20:
+  Warning("ReadEuclidMedia","reading error or premature end of file\n");
+} 
+
+//_______________________________________________________________________
+void AliModule::RemapTrackReferencesIDs(Int_t *map)
+{
+  // 
+  // Remapping track reference
+  // Called at finish primary
+  //
+  if (!fTrackReferences) return;
+  for (Int_t i=0;i<fTrackReferences->GetEntries();i++){
+    AliTrackReference * ref = dynamic_cast<AliTrackReference*>(fTrackReferences->UncheckedAt(i));
+    if (ref) {
+      Int_t newID = map[ref->GetTrack()];
+      if (newID>=0) ref->SetTrack(newID);
+      else {
+        //ref->SetTrack(-1);
+        ref->SetBit(kNotDeleted,kFALSE);
+        fTrackReferences->RemoveAt(i);  
+      }      
+    }
   }
+  fTrackReferences->Compress();
+
+}
+
+
+//_______________________________________________________________________
+AliTrackReference* AliModule::FirstTrackReference(Int_t track)
+{
+  //
+  // Initialise the hit iterator
+  // Return the address of the first hit for 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) 
+   {
+     AliRunLoader* rl = AliRunLoader::GetRunLoader();
+
+     rl->GetAliRun()->ResetTrackReferences();
+     rl->TreeTR()->GetEvent(track);
+     if (rl == 0x0)
+       Fatal("FirstTrackReference","AliRunLoader not initialized. Can not proceed");
+   }
+  //
+  fMaxIterTrackRef     = fTrackReferences->GetEntriesFast();
+  fCurrentIterTrackRef = 0;
+  if(fMaxIterTrackRef) return dynamic_cast<AliTrackReference*>(fTrackReferences->UncheckedAt(0));
+  else            return 0;
+}
+
+//_______________________________________________________________________
+AliTrackReference* AliModule::NextTrackReference()
+{
+  //
+  // Return the next hit for the current track
+  //
+  if(fMaxIterTrackRef) {
+    if(++fCurrentIterTrackRef<fMaxIterTrackRef) 
+      return dynamic_cast<AliTrackReference*>(fTrackReferences->UncheckedAt(fCurrentIterTrackRef));
+    else        
+      return 0;
+  } else {
+    printf("* AliModule::NextTrackReference * TrackReference  Iterator called without calling FistTrackReference before\n");
+    return 0;
+  }
+}
+
+
+//_______________________________________________________________________
+void AliModule::ResetTrackReferences()
+{
+  //
+  // Reset number of hits and the hits array
+  //
+  fMaxIterTrackRef   = 0;
+  if (fTrackReferences)   fTrackReferences->Clear();
 }
  
+//_____________________________________________________________________________
+
+AliLoader*  AliModule::MakeLoader(const char* /*topfoldername*/) 
+ {
+   return 0x0;
+ }//skowron   
+//PH Merged with v3-09-08 |
+//                        V
+//_____________________________________________________________________________
+
+void AliModule::SetTreeAddress()
+{
+  //
+  // Set branch address for track reference Tree
+  //
+
+  TBranch *branch;
+
+  // Branch address for track reference tree
+  TTree *treeTR = TreeTR();
+
+  if (treeTR && fTrackReferences) {
+     branch = treeTR->GetBranch(GetName());
+    if (branch) 
+     {
+       if(GetDebug()) 
+         Info("SetTreeAddress","(%s) Setting for TrackRefs",GetName());
+       branch->SetAddress(&fTrackReferences);
+     }
+    else
+     { 
+     //can be called before MakeBranch and than does not make sense to issue the warning
+       if(GetDebug()) 
+         Warning("SetTreeAddress",
+                 "(%s) Failed for Track References. Can not find branch in tree.",
+                 GetName());
+     }
+  }
+}
+
+//_____________________________________________________________________________
+void  AliModule::AddTrackReference(Int_t label){
+  //
+  // add a trackrefernce to the list
+  if (!fTrackReferences) {
+    cerr<<"Container trackrefernce not active\n";
+    return;
+  }
+  Int_t nref = fTrackReferences->GetEntriesFast();
+  TClonesArray &lref = *fTrackReferences;
+  new(lref[nref]) AliTrackReference(label);
+}
+
+
+//_____________________________________________________________________________
+void AliModule::MakeBranchTR(Option_t */*option*/)
+{ 
+    //
+    // Makes branch in treeTR
+    //  
+  if(GetDebug()) Info("MakeBranchTR","Making Track Refs. Branch for %s",GetName());
+  TTree * tree = TreeTR();
+  if (fTrackReferences && tree) 
+   {
+      TBranch *branch = tree->GetBranch(GetName());
+     if (branch) 
+       {  
+        if(GetDebug()) Info("MakeBranch","Branch %s is already in tree.",GetName());
+        return;
+       }
+  
+     branch = tree->Branch(GetName(),&fTrackReferences);
+   }
+  else
+    {
+      if(GetDebug()) 
+       Info("MakeBranchTR","FAILED for %s: tree=%#x fTrackReferences=%#x",
+            GetName(),tree,fTrackReferences);
+    }
+}
+
+//_____________________________________________________________________________
+TTree* AliModule::TreeTR()
+{
+  AliRunLoader* rl = AliRunLoader::GetRunLoader();
+
+  if ( rl == 0x0)
+   {
+     Error("TreeTR","Can not get the run loader");
+     return 0x0;
+   }
+
+  TTree* tree = rl->TreeTR();
+  return tree;
+}