Changes made to support PreDigits (SDigits) plus other helpful changes.
authornilsen <nilsen@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 4 Oct 2001 22:38:10 +0000 (22:38 +0000)
committernilsen <nilsen@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 4 Oct 2001 22:38:10 +0000 (22:38 +0000)
ITS/AliITS.cxx
ITS/AliITS.h
ITS/AliITSresponseSDD.cxx
ITS/AliITSresponseSDD.h
ITS/AliITSresponseSPD.cxx
ITS/AliITSresponseSPD.h
ITS/AliITSresponseSSD.h

index 39a2cc8..95de84b 100644 (file)
@@ -15,6 +15,9 @@
 
 /*
 $Log$
+Revision 1.59  2001/08/30 09:56:18  hristov
+The operator[] is replaced by At() or AddAt() in case of TObjArray.
+
 Revision 1.58  2001/07/26 15:05:29  hristov
 Use global gRandom generator (M.Ivanov)
 
@@ -238,8 +241,6 @@ the AliITS class.
 #include <TTree.h>
 #include <TString.h>
 
-
-
 #include "AliMC.h"
 #include "AliRun.h"
 #include "AliHeader.h"
@@ -258,782 +259,409 @@ the AliITS class.
 #include "AliITSClusterFinderSPD.h"
 #include "AliITSClusterFinderSDD.h"
 #include "AliITSClusterFinderSSD.h"
-
 #include "AliITShit.h"
 #include "AliITSgeom.h"
+#include "AliITSpList.h"
 #include "AliITSdigit.h"
 #include "AliITSmodule.h"
 #include "AliITSRecPoint.h"
 #include "AliITSRawCluster.h"
 
-
 ClassImp(AliITS)
-//_____________________________________________________________________________
-AliITS::AliITS() : AliDetector() {
-  //
-  // Default initialiser for ITS
-  //     The default constructor of the AliITS class. In addition to
-  // creating the AliITS class it zeros the variables fIshunt (a member
-  // of AliDetector class), fEuclidOut, and fIdN, and zeros the pointers
-  // fITSpoints, fIdSens, and fIdName. The AliDetector default constructor
-  // is also called.
-  //
-
-
-  fIshunt     = 0;
-  fEuclidOut  = 0;
-
-  fNDetTypes = kNTYPES;
-  fIdN        = 0;
-  fIdName     = 0;
-  fIdSens     = 0;
-  fITSmodules = 0;
-  //
-  fDetTypes   = 0;
-  //
-  fDtype  = 0;
-  fNdtype = 0;
-  fCtype  = 0;
-  fNctype = 0;
-  fRecPoints = 0;
-  fNRecPoints = 0;
-  fTreeC = 0;
-  //
-  fITSgeom=0;
-}
-
-//_____________________________________________________________________________
-AliITS::AliITS(const char *name, const char *title):AliDetector(name,title){
-  //
-  // Default initialiser for ITS
-  //     The constructor of the AliITS class. In addition to creating the
-  // AliITS class, it allocates memory for the TClonesArrays fHits and
-  // fDigits, and for the TObjArray fITSpoints. It also zeros the variables
-  // fIshunt (a member of AliDetector class), fEuclidOut, and fIdN, and zeros
-  // the pointers fIdSens and fIdName. To help in displaying hits via the ROOT
-  // macro display.C AliITS also sets the marker color to red. The variables
-  // passes with this constructor, const char *name and *title, are used by
-  // the constructor of AliDetector class. See AliDetector class for a
-  // description of these parameters and its constructor functions.
-  //
-
-
-  fHits       = new TClonesArray("AliITShit", 1560);
-  gAlice->AddHitList(fHits);
 
-  fNDetTypes = kNTYPES;
-
-  fNdtype = new Int_t[kNTYPES];
-  fDtype = new TObjArray(kNTYPES);
-
-  fNctype = new Int_t[kNTYPES];
-  fCtype = new TObjArray(kNTYPES);
+//______________________________________________________________________
+AliITS::AliITS() : AliDetector() {
+    // Default initialiser for ITS
+    //      The default constructor of the AliITS class. In addition to
+    // creating the AliITS class it zeros the variables fIshunt (a member
+    // of AliDetector class), fEuclidOut, and fIdN, and zeros the pointers
+    // fITSpoints, fIdSens, and fIdName. The AliDetector default constructor
+    // is also called.
 
+    fIshunt     = 0;   // not zeroed in AliDetector.
 
+    // AliITS variables.
+    fEuclidOut  = 0;
+    fITSgeom    = 0;
+    fITSmodules = 0;
 
-  fRecPoints=new TClonesArray("AliITSRecPoint",1000);
-  fNRecPoints = 0;
+    fIdN        = 0;
+    fIdName     = 0;
+    fIdSens     = 0;
 
-  fTreeC = 0;
+    fNDetTypes  = kNTYPES;
+    fDetTypes   = 0;
 
-  fITSmodules = 0; 
+    fSDigits    = 0;
+    fNSDigits   = 0;
 
-  fIshunt     = 0;
-  fEuclidOut  = 0;
-  fIdN        = 0;
-  fIdName     = 0;
-  fIdSens     = 0;
-  fDetTypes = new TObjArray(kNTYPES);  
+    fNdtype     = 0;
+    fDtype      = 0;
 
-  Int_t i;
-  for(i=0;i<kNTYPES;i++) {
-    fDetTypes->AddAt(new AliITSDetType(),i); 
-    fNdtype[i]=0;
-    fNctype[i]=0;
-   }
-  //
+    fCtype      = 0;
+    fNctype     = 0;
+    fTreeC      = 0;
 
-  SetMarkerColor(kRed);
+    fRecPoints  = 0;
+    fNRecPoints = 0;
 
-  fITSgeom=0;
-}
-//___________________________________________________________________________
-AliITS::AliITS(AliITS &source){
-  // copy constructor
-  if(this==&source) return;
-  Error("AliITS::Copy constructor",
-       "You are not allowed to make a copy of the AliITS");
-  exit(1);
+    SetMarkerColor(kRed);
 }
-//____________________________________________________________________________
-AliITS& AliITS::operator=(AliITS &source){
-  // assignment operator
-  if(this==&source) return *this;
-  Error("AliITS::operator=",
-       "You are not allowed to make a copy of the AliITS");
-  exit(1);
-  return *this; //fake return
-}
-//____________________________________________________________________________
-void AliITS::ClearModules(){
-  //clear the modules TObjArray
+//______________________________________________________________________
+AliITS::AliITS(const char *name, const char *title):AliDetector(name,title){
+    // Default initialiser for ITS
+    //     The constructor of the AliITS class. In addition to creating the
+    // AliITS class, it allocates memory for the TClonesArrays fHits and
+    // fDigits, and for the TObjArray fITSpoints. It also zeros the variables
+    // fIshunt (a member of AliDetector class), fEuclidOut, and fIdN, and zeros
+    // the pointers fIdSens and fIdName. To help in displaying hits via the
+    // ROOT macro display.C AliITS also sets the marker color to red. The
+    // variables passes with this constructor, const char *name and *title,
+    // are used by the constructor of AliDetector class. See AliDetector
+    // class for a description of these parameters and its constructor
+    // functions.
+
+    fIshunt     = 0;  // not zeroed in AliDetector
+    fHits       = new TClonesArray("AliITShit", 1560);//not done in AliDetector
+    gAlice->AddHitList(fHits);  // Not done in AliDetector.
+
+    fEuclidOut  = 0;
+    fITSgeom    = 0;
+    fITSmodules = 0;
+
+    fIdN        = 0;
+    fIdName     = 0;
+    fIdSens     = 0;
+
+    fNDetTypes  = kNTYPES;
+    fDetTypes   = new TObjArray(fNDetTypes);
+
+//    fSDigits    = new TObjArray(1000);
+    fSDigits    = new TClonesArray("AliITSpListItem",1000);
+    fNSDigits   = 0;
+
+    fNdtype     = new Int_t[fNDetTypes];
+    fDtype      = new TObjArray(fNDetTypes);
+
+    fCtype      = new TObjArray(fNDetTypes);
+    fNctype     = new Int_t[fNDetTypes];
+    fTreeC      = 0;
+
+    fRecPoints  = new TClonesArray("AliITSRecPoint",1000);
+    fNRecPoints = 0;
 
-  if(fITSmodules) fITSmodules->Delete();
+    Int_t i;
+    for(i=0;i<fNDetTypes;i++) {
+       fDetTypes->AddAt(new AliITSDetType(),i); 
+       fNdtype[i] = 0;
+       fNctype[i] = 0;
+    } // end for i
 
+    SetMarkerColor(kRed);
 }
-//_____________________________________________________________________________
+//______________________________________________________________________
 AliITS::~AliITS(){
-  //
-  // Default distructor for ITS
-  //     The default destructor of the AliITS class. In addition to deleting
-  // the AliITS class it deletes the memory pointed to by the fHits, fDigits,
-  // fIdSens, fIdName, and fITSpoints.
-  //
-
-
-  delete fHits;
-  delete fDigits;
-  delete fRecPoints;
+    // Default distructor for ITS
+    //     The default destructor of the AliITS class. In addition to deleting
+    // the AliITS class it deletes the memory pointed to by the fHits, fDigits,
+    // fIdSens, fIdName, and fITSpoints.
+
+    delete fHits;
+    delete fSDigits;
+    delete fDigits;
+    delete fRecPoints;
 //  delete fIdName;        // TObjArray of TObjStrings
-  if(fIdName!=0) delete[] fIdName;  // Array of TStrings
-  if(fIdSens!=0) delete[] fIdSens;
-  if(fITSmodules!=0) {
-      this->ClearModules();
-      delete fITSmodules;
-  }// end if fITSmodules!=0
-
-  //
-  if(fDtype) {
-    fDtype->Delete();
-    delete fDtype;
-  }
-  delete [] fNdtype;
-  if (fCtype) {
-    fCtype->Delete();
-    delete fCtype;
-  }
-  delete [] fNctype;
-  //
-
-  if (fDetTypes) {
-    fDetTypes->Delete();
-    delete fDetTypes;
-  }
-
-  if (fTreeC) delete fTreeC;
-
-  if (fITSgeom) delete fITSgeom;
-
-}
-
-//___________________________________________
-AliITSDetType* AliITS::DetType(Int_t id)
-{
-  //return pointer to id detector type
-  //PH    return ((AliITSDetType*) (*fDetTypes)[id]);
-    return ((AliITSDetType*) fDetTypes->At(id));
-
-}
-//___________________________________________
-void AliITS::SetClasses(Int_t id, const char *digit, const char *cluster)
-{
-  //set the digit and cluster classes to be used for the id detector type
-  //PH    ((AliITSDetType*) (*fDetTypes)[id])->ClassNames(digit,cluster);
-    ((AliITSDetType*) fDetTypes->At(id))->ClassNames(digit,cluster);
-
-}
-//___________________________________________
-void AliITS::SetResponseModel(Int_t id, AliITSresponse *response)
-{
-  //set the response model for the id detector type
-
-  //PH    ((AliITSDetType*) (*fDetTypes)[id])->ResponseModel(response);
-    ((AliITSDetType*) fDetTypes->At(id))->ResponseModel(response);
-
-}
-
-//___________________________________________
-void AliITS::SetSegmentationModel(Int_t id, AliITSsegmentation *seg)
-{
-  //set the segmentation model for the id detector type
-
-  //PH    ((AliITSDetType*) (*fDetTypes)[id])->SegmentationModel(seg);
-    ((AliITSDetType*) fDetTypes->At(id))->SegmentationModel(seg);
-
-}
-
-//___________________________________________
-void AliITS::SetSimulationModel(Int_t id, AliITSsimulation *sim)
-{
-  //set the simulation model for the id detector type
-
-  //PH   ((AliITSDetType*) (*fDetTypes)[id])->SimulationModel(sim);
-   ((AliITSDetType*) fDetTypes->At(id))->SimulationModel(sim);
-
-}
-//___________________________________________
-void AliITS::SetReconstructionModel(Int_t id, AliITSClusterFinder *reconst)
-{
-  //set the cluster finder model for the id detector type
-
-  //PH   ((AliITSDetType*) (*fDetTypes)[id])->ReconstructionModel(reconst);
-   ((AliITSDetType*) fDetTypes->At(id))->ReconstructionModel(reconst);
-
-}
-
-//_____________________________________________________________________________
-void AliITS::AddHit(Int_t track, Int_t *vol, Float_t *hits){
-  //
-  // Add an ITS hit
-  //     The function to add information to the AliITShit class. See the
-  // AliITShit class for a full description. This function allocates the
-  // necessary new space for the hit information and passes the variable
-  // track, and the pointers *vol and *hits to the AliITShit constructor
-  // function.
-  //
-  TClonesArray &lhits = *fHits;
-  new(lhits[fNhits++]) AliITShit(fIshunt,track,vol,hits);
-}
-//_____________________________________________________________________________
-void AliITS::AddRealDigit(Int_t id, Int_t *digits) 
-{
-  // add a real digit - as coming from data
-
-  //PH  TClonesArray &ldigits = *((TClonesArray*)(*fDtype)[id]);
-  TClonesArray &ldigits = *((TClonesArray*)fDtype->At(id));
-  new(ldigits[fNdtype[id]++]) AliITSdigit(digits);
-
-}
-//_____________________________________________________________________________
-void AliITS::AddSimDigit(Int_t id, AliITSdigit *d) 
-{
-
-  // add a simulated digit
-
-  //PH  TClonesArray &ldigits = *((TClonesArray*)(*fDtype)[id]);
-  TClonesArray &ldigits = *((TClonesArray*)fDtype->At(id));
-
-  switch(id)
-  {
-  case 0:
-     new(ldigits[fNdtype[id]++]) AliITSdigitSPD(*((AliITSdigitSPD*)d));
-     break;
-  case 1:
-     new(ldigits[fNdtype[id]++]) AliITSdigitSDD(*((AliITSdigitSDD*)d));
-     break;
-  case 2:
-     new(ldigits[fNdtype[id]++]) AliITSdigitSSD(*((AliITSdigitSSD*)d));
-     break;
-  }
-
+    if(fIdName!=0) delete[] fIdName;  // Array of TStrings
+    if(fIdSens!=0) delete[] fIdSens;
+    if(fITSmodules!=0) {
+       this->ClearModules();
+       delete fITSmodules;
+    }// end if fITSmodules!=0
+
+    if(fDtype) {
+       fDtype->Delete();
+       delete fDtype;
+    } // end if fDtype
+    delete [] fNdtype;
+    if (fCtype) {
+       fCtype->Delete();
+       delete fCtype;
+    } // end if fCtype
+    delete [] fNctype;
+
+    if (fDetTypes) {
+       fDetTypes->Delete();
+       delete fDetTypes;
+    } // end if fDetTypes
+
+    if (fTreeC) delete fTreeC;
+
+    if (fITSgeom) delete fITSgeom;
 }
+//______________________________________________________________________
+AliITS::AliITS(AliITS &source){
+    // copy constructor
 
-//_____________________________________________________________________________
-void AliITS::AddSimDigit(Int_t id,Float_t phys,Int_t *digits,Int_t *tracks,Int_t *hits,Float_t *charges){
-
-  // add a simulated digit to the list
-
-  //PH  TClonesArray &ldigits = *((TClonesArray*)(*fDtype)[id]);
-  TClonesArray &ldigits = *((TClonesArray*)fDtype->At(id));
-  switch(id)
-  {
-  case 0:
-     new(ldigits[fNdtype[id]++]) AliITSdigitSPD(digits,tracks,hits);
-     break;
-  case 1:
-     new(ldigits[fNdtype[id]++]) AliITSdigitSDD(phys,digits,tracks,hits,charges);
-     break;
-  case 2:
-     new(ldigits[fNdtype[id]++]) AliITSdigitSSD(digits,tracks,hits);
-     break;
-  }
+    if(this==&source) return;
+    Error("AliITS::Copy constructor",
+         "You are not allowed to make a copy of the AliITS");
+    exit(1);
 }
+//______________________________________________________________________
+AliITS& AliITS::operator=(AliITS &source){
+    // assignment operator
 
-//_____________________________________________________________________________
-void AliITS::AddCluster(Int_t id, AliITSRawCluster *c) 
-{
-
-  // add a cluster to the list
-
-  //PH  TClonesArray &lcl = *((TClonesArray*)(*fCtype)[id]);
-  TClonesArray &lcl = *((TClonesArray*)fCtype->At(id));
-
-  switch(id)
-  {
-  case 0:
-     new(lcl[fNctype[id]++]) AliITSRawClusterSPD(*((AliITSRawClusterSPD*)c));
-     break;
-  case 1:
-     new(lcl[fNctype[id]++]) AliITSRawClusterSDD(*((AliITSRawClusterSDD*)c));
-     break;
-  case 2:
-     new(lcl[fNctype[id]++]) AliITSRawClusterSSD(*((AliITSRawClusterSSD*)c));
-     break;
-  }
-
+    if(this==&source) return *this;
+    Error("AliITS::operator=",
+         "You are not allowed to make a copy of the AliITS");
+    exit(1);
+    return *this; //fake return
 }
+//______________________________________________________________________
+Int_t AliITS::DistancetoPrimitive(Int_t , Int_t ){
+    // Distance from mouse to ITS on the screen. Dummy routine
+    //     A dummy routine used by the ROOT macro display.C to allow for the
+    // use of the mouse (pointing device) in the macro. In general this should
+    // never be called. If it is it returns the number 9999 for any value of
+    // x and y.
 
-
-//_____________________________________________________________________________
-void AliITS::AddRecPoint(const AliITSRecPoint &r)
-{
-  //
-  // Add a reconstructed space point to the list
-  //
-  TClonesArray &lrecp = *fRecPoints;
-  new(lrecp[fNRecPoints++]) AliITSRecPoint(r);
+    return 9999;
 }
-
-//____________________________________________
-void AliITS::ResetDigits()
-{
-    //
-    // Reset number of digits and the digits array for the ITS detector
-    //
-
-    if (!fDtype) return;
-
+//______________________________________________________________________
+void AliITS::Init(){
+    // Initialise ITS after it has been built
+    //     This routine initializes the AliITS class. It is intended to be
+    // called from the Init function in AliITSv?. Besides displaying a banner
+    // indicating that it has been called it initializes the array fIdSens
+    // and sets the default segmentation, response, digit and raw cluster
+    // classes therefore it should be called after a call to CreateGeometry.
     Int_t i;
-    for (i=0;i<kNTYPES;i++ ) {
-      //PH     if ((*fDtype)[i])    ((TClonesArray*)(*fDtype)[i])->Clear();
-       if (fDtype->At(i))    ((TClonesArray*)fDtype->At(i))->Clear();
-       if (fNdtype)  fNdtype[i]=0;
-    }
-}
 
-//____________________________________________
-void AliITS::ResetDigits(Int_t i)
-{
-    //
-    // Reset number of digits and the digits array for this branch
-    //
-  //PH  if ((*fDtype)[i])    ((TClonesArray*)(*fDtype)[i])->Clear();
-  if (fDtype->At(i))    ((TClonesArray*)fDtype->At(i))->Clear();
-  if (fNdtype)  fNdtype[i]=0;
+    SetDefaults();
+    // Array of TStrings
+    for(i=0;i<fIdN;i++) fIdSens[i] = gMC->VolId(fIdName[i]);
 }
-
-
-//____________________________________________
-void AliITS::ResetClusters()
-{
-    //
-    // Reset number of clusters and the clusters array for ITS
-    //
-
-    Int_t i;
-    for (i=0;i<kNTYPES;i++ ) {
-      //PH     if ((*fCtype)[i])    ((TClonesArray*)(*fCtype)[i])->Clear();
-       if (fCtype->At(i))    ((TClonesArray*)fCtype->At(i))->Clear();
-       if (fNctype)  fNctype[i]=0;
-    }
-
+//______________________________________________________________________
+void AliITS::SetDefaults(){
+    // sets the default segmentation, response, digit and raw cluster classes
+
+    if(fDebug) printf("%s: SetDefaults\n",ClassName());
+
+    AliITSDetType *iDetType;
+
+    //SPD
+    iDetType=DetType(0); 
+    if (!iDetType->GetSegmentationModel()) {
+       AliITSsegmentationSPD *seg0=new AliITSsegmentationSPD(fITSgeom);
+       SetSegmentationModel(0,seg0); 
+    } // end if
+    if (!iDetType->GetResponseModel()) {
+       SetResponseModel(0,new AliITSresponseSPD()); 
+    } // end if
+    // set digit and raw cluster classes to be used
+
+    const char *kData0=(iDetType->GetResponseModel())->DataType();
+    if (strstr(kData0,"real")) {
+       iDetType->ClassNames("AliITSdigit","AliITSRawClusterSPD");
+    } else iDetType->ClassNames("AliITSdigitSPD","AliITSRawClusterSPD");
+
+    // SDD
+    iDetType=DetType(1); 
+    if (!iDetType->GetResponseModel()) {
+       SetResponseModel(1,new AliITSresponseSDD()); 
+    } // end if
+    AliITSresponse *resp1=iDetType->GetResponseModel();
+    if (!iDetType->GetSegmentationModel()) {
+       AliITSsegmentationSDD *seg1=new AliITSsegmentationSDD(fITSgeom,resp1);
+       SetSegmentationModel(1,seg1); 
+    } // end if
+    const char *kData1=(iDetType->GetResponseModel())->DataType();
+    const char *kopt=iDetType->GetResponseModel()->ZeroSuppOption();
+    if((!strstr(kopt,"2D")) && (!strstr(kopt,"1D")) || strstr(kData1,"real") ){
+       iDetType->ClassNames("AliITSdigit","AliITSRawClusterSDD");
+    } else iDetType->ClassNames("AliITSdigitSDD","AliITSRawClusterSDD");
+
+    // SSD
+    iDetType=DetType(2); 
+    if (!iDetType->GetSegmentationModel()) {
+       AliITSsegmentationSSD *seg2=new AliITSsegmentationSSD(fITSgeom);
+       SetSegmentationModel(2,seg2); 
+    } // end if
+    if (!iDetType->GetResponseModel()) {
+       SetResponseModel(2,new AliITSresponseSSD()); 
+    } // end if
+    const char *kData2=(iDetType->GetResponseModel())->DataType();
+    if (strstr(kData2,"real")) {
+       iDetType->ClassNames("AliITSdigit","AliITSRawClusterSSD");
+    } else iDetType->ClassNames("AliITSdigitSSD","AliITSRawClusterSSD");
+
+    if (kNTYPES>3) {
+       Warning("SetDefaults",
+               "Only the three basic detector types are initialised!");
+    }  // end if
 }
-
-//____________________________________________
-void AliITS::ResetClusters(Int_t i)
-{
-    //
-    // Reset number of clusters and the clusters array for this branch
-    //
-  //PH if ((*fCtype)[i])    ((TClonesArray*)(*fCtype)[i])->Clear();
-       if (fCtype->At(i))    ((TClonesArray*)fCtype->At(i))->Clear();
-       if (fNctype)  fNctype[i]=0;
-
+//______________________________________________________________________
+void AliITS::SetDefaultSimulation(){
+    // sets the default simulation
+
+    AliITSDetType *iDetType;
+    iDetType=DetType(0);
+    if (!iDetType->GetSimulationModel()) {
+       AliITSsegmentation *seg0=
+           (AliITSsegmentation*)iDetType->GetSegmentationModel();
+       AliITSresponse *res0 = (AliITSresponse*)iDetType->GetResponseModel();
+       AliITSsimulationSPD *sim0=new AliITSsimulationSPD(seg0,res0);
+       SetSimulationModel(0,sim0);
+    } // end if
+    iDetType=DetType(1);
+    if (!iDetType->GetSimulationModel()) {
+       AliITSsegmentation *seg1=
+           (AliITSsegmentation*)iDetType->GetSegmentationModel();
+       AliITSresponse *res1 = (AliITSresponse*)iDetType->GetResponseModel();
+       AliITSsimulationSDD *sim1=new AliITSsimulationSDD(seg1,res1);
+       SetSimulationModel(1,sim1);
+    } //end if
+    iDetType=DetType(2);
+    if (!iDetType->GetSimulationModel()) {
+       AliITSsegmentation *seg2=
+           (AliITSsegmentation*)iDetType->GetSegmentationModel();
+       AliITSresponse *res2 = (AliITSresponse*)iDetType->GetResponseModel();
+       AliITSsimulationSSD *sim2=new AliITSsimulationSSD(seg2,res2);
+       SetSimulationModel(2,sim2);
+    } // end if
 }
-
-
-//____________________________________________
-void AliITS::ResetRecPoints()
-{
-    //
-    // Reset number of rec points and the rec points array 
-    //
-    if (fRecPoints) fRecPoints->Clear();
-    fNRecPoints = 0;
-
+//______________________________________________________________________
+void AliITS::SetDefaultClusterFinders(){
+    // sets the default cluster finders
+
+    MakeTreeC();
+    AliITSDetType *iDetType;
+
+    // SPD
+    iDetType=DetType(0);
+    if (!iDetType->GetReconstructionModel()) {
+       AliITSsegmentation *seg0 =
+           (AliITSsegmentation*)iDetType->GetSegmentationModel();
+       TClonesArray *dig0=DigitsAddress(0);
+       TClonesArray *recp0=ClustersAddress(0);
+       AliITSClusterFinderSPD *rec0 = new AliITSClusterFinderSPD(seg0,dig0,
+                                                                 recp0);
+       SetReconstructionModel(0,rec0);
+    } // end if
+
+    // SDD
+    iDetType=DetType(1);
+    if (!iDetType->GetReconstructionModel()) {
+       AliITSsegmentation *seg1 =
+           (AliITSsegmentation*)iDetType->GetSegmentationModel();
+       AliITSresponse *res1 = (AliITSresponse*)iDetType->GetResponseModel();
+       TClonesArray *dig1=DigitsAddress(1);
+       TClonesArray *recp1=ClustersAddress(1);
+       AliITSClusterFinderSDD *rec1 =
+           new AliITSClusterFinderSDD(seg1,res1,dig1,recp1);
+      SetReconstructionModel(1,rec1);
+    } // end if
+
+    // SSD
+    iDetType=DetType(2);
+    if (!iDetType->GetReconstructionModel()) {
+       AliITSsegmentation *seg2=
+           (AliITSsegmentation*)iDetType->GetSegmentationModel();
+       TClonesArray *dig2=DigitsAddress(2);
+       AliITSClusterFinderSSD *rec2= new AliITSClusterFinderSSD(seg2,dig2);
+       SetReconstructionModel(2,rec2);
+    } // end if
 }
-
-//_____________________________________________________________________________
-Int_t AliITS::DistancetoPrimitive(Int_t , Int_t ){
-  //
-  // Distance from mouse to ITS on the screen. Dummy routine
-  //     A dummy routine used by the ROOT macro display.C to allow for the
-  // use of the mouse (pointing device) in the macro. In general this should
-  // never be called. If it is it returns the number 9999 for any value of
-  // x and y.
-  //
-  return 9999;
+//______________________________________________________________________
+void AliITS::MakeBranch(Option_t* option, const char *file){
+    // Creates Tree branches for the ITS.
+    const char *cS = strstr(option,"S");
+    const char *cD = strstr(option,"D");
+    const char *cR = strstr(option,"R");
+
+    AliDetector::MakeBranch(option,file);
+
+    if(cS) MakeBranchS(file);
+    if(cD) MakeBranchD(file);
+    if(cR) MakeBranchR(file);
 }
-
-//_____________________________________________________________________________
-void AliITS::Init(){
-  //
-  // Initialise ITS after it has been built
-  //     This routine initializes the AliITS class. It is intended to be called
-  // from the Init function in AliITSv?. Besides displaying a banner
-  // indicating that it has been called it initializes the array fIdSens
-  // and sets the default segmentation, response, digit and raw cluster classes
-  // Therefore it should be called after a call to CreateGeometry.
-  //
-  Int_t i;
-
-//
-  SetDefaults();
-// Array of TStrings
-  for(i=0;i<fIdN;i++) fIdSens[i] = gMC->VolId(fIdName[i]);
-//
+//______________________________________________________________________
+void AliITS::SetTreeAddress(){
+    // Set branch address for the Trees.
+    TTree *treeS = gAlice->TreeS();
+    TTree *treeD = gAlice->TreeD();
+    TTree *treeR = gAlice->TreeR();
+
+    AliDetector::SetTreeAddress();
+
+    SetTreeAddressS(treeS);
+    SetTreeAddressD(treeD);
+    SetTreeAddressR(treeR);
 }
+//______________________________________________________________________
+AliITSDetType* AliITS::DetType(Int_t id){
+    //return pointer to id detector type
 
-//_____________________________________________________________________________
-void AliITS::SetDefaults()
-{
-  // sets the default segmentation, response, digit and raw cluster classes
-
-  if(fDebug) printf("%s: SetDefaults\n",ClassName());
-
-  AliITSDetType *iDetType;
-
-
-  //SPD 
-
-  iDetType=DetType(0); 
-  if (!iDetType->GetSegmentationModel()) {
-    AliITSsegmentationSPD *seg0=new AliITSsegmentationSPD(fITSgeom);
-    SetSegmentationModel(0,seg0); 
-  }
-  if (!iDetType->GetResponseModel()) {
-     SetResponseModel(0,new AliITSresponseSPD()); 
-  }
-  // set digit and raw cluster classes to be used
-  
-  const char *kData0=(iDetType->GetResponseModel())->DataType();
-  if (strstr(kData0,"real")) {
-      iDetType->ClassNames("AliITSdigit","AliITSRawClusterSPD");
-  } else iDetType->ClassNames("AliITSdigitSPD","AliITSRawClusterSPD");
-
-  // SDD                                         //
-  iDetType=DetType(1); 
-  if (!iDetType->GetResponseModel()) {
-    SetResponseModel(1,new AliITSresponseSDD()); 
-  }
-  AliITSresponse *resp1=iDetType->GetResponseModel();
-  if (!iDetType->GetSegmentationModel()) {
-    AliITSsegmentationSDD *seg1=new AliITSsegmentationSDD(fITSgeom,resp1);
-    SetSegmentationModel(1,seg1); 
-  }
-  const char *kData1=(iDetType->GetResponseModel())->DataType();
-  const char *kopt=iDetType->GetResponseModel()->ZeroSuppOption();
-  if ((!strstr(kopt,"2D")) && (!strstr(kopt,"1D")) || strstr(kData1,"real") ) {
-      iDetType->ClassNames("AliITSdigit","AliITSRawClusterSDD");
-  } else iDetType->ClassNames("AliITSdigitSDD","AliITSRawClusterSDD");
-
-  // SSD
-  iDetType=DetType(2); 
-  if (!iDetType->GetSegmentationModel()) {
-    AliITSsegmentationSSD *seg2=new AliITSsegmentationSSD(fITSgeom);
-    SetSegmentationModel(2,seg2); 
-  }
-  if (!iDetType->GetResponseModel()) {
-    SetResponseModel(2,new AliITSresponseSSD()); 
-  }
-  const char *kData2=(iDetType->GetResponseModel())->DataType();
-  if (strstr(kData2,"real")) {
-      iDetType->ClassNames("AliITSdigit","AliITSRawClusterSSD");
-  } else iDetType->ClassNames("AliITSdigitSSD","AliITSRawClusterSSD");
-
-  if (kNTYPES>3) {
-    Warning("SetDefaults","Only the three basic detector types are initialised!");
-  } 
-
+    return ((AliITSDetType*) fDetTypes->At(id));
 }
-//_____________________________________________________________________________
-void AliITS::SetDefaultSimulation()
-{
-  // sets the default simulation
-
-
-  AliITSDetType *iDetType;
-  iDetType=DetType(0);
-  if (!iDetType->GetSimulationModel()) {
-      AliITSsegmentation *seg0=
-                    (AliITSsegmentation*)iDetType->GetSegmentationModel();
-      AliITSresponse *res0 = (AliITSresponse*)iDetType->GetResponseModel();
-      AliITSsimulationSPD *sim0=new AliITSsimulationSPD(seg0,res0);
-      SetSimulationModel(0,sim0);
-  }
-  iDetType=DetType(1);
-  if (!iDetType->GetSimulationModel()) {
-      AliITSsegmentation *seg1=
-                    (AliITSsegmentation*)iDetType->GetSegmentationModel();
-      AliITSresponse *res1 = (AliITSresponse*)iDetType->GetResponseModel();
-      AliITSsimulationSDD *sim1=new AliITSsimulationSDD(seg1,res1);
-      SetSimulationModel(1,sim1);
-  }
-  iDetType=DetType(2);
-  if (!iDetType->GetSimulationModel()) {
-      AliITSsegmentation *seg2=
-                    (AliITSsegmentation*)iDetType->GetSegmentationModel();
-      AliITSresponse *res2 = (AliITSresponse*)iDetType->GetResponseModel();
-      AliITSsimulationSSD *sim2=new AliITSsimulationSSD(seg2,res2);
-      SetSimulationModel(2,sim2);
-  }
-
+//______________________________________________________________________
+void AliITS::SetResponseModel(Int_t id, AliITSresponse *response){
+    //set the response model for the id detector type
 
+    ((AliITSDetType*) fDetTypes->At(id))->ResponseModel(response);
 }
-//_____________________________________________________________________________
-void AliITS::SetDefaultClusterFinders()
-{
-  // sets the default cluster finders
-
-  MakeTreeC();
-  AliITSDetType *iDetType;
-  iDetType=DetType(0);
-  if (!iDetType->GetReconstructionModel()) {
-      AliITSsegmentation *seg0=
-                   (AliITSsegmentation*)iDetType->GetSegmentationModel();
-      TClonesArray *dig0=DigitsAddress(0);
-      TClonesArray *recp0=ClustersAddress(0);
-      AliITSClusterFinderSPD *rec0=new AliITSClusterFinderSPD(seg0,dig0,recp0);
-      SetReconstructionModel(0,rec0);
-  }
-  iDetType=DetType(1);
-  if (!iDetType->GetReconstructionModel()) {
-      AliITSsegmentation *seg1=
-                     (AliITSsegmentation*)iDetType->GetSegmentationModel();
-      AliITSresponse *res1 = (AliITSresponse*)iDetType->GetResponseModel();
-      TClonesArray *dig1=DigitsAddress(1);
-      TClonesArray *recp1=ClustersAddress(1);
-      AliITSClusterFinderSDD *rec1=
-                           new AliITSClusterFinderSDD(seg1,res1,dig1,recp1);
-
-      SetReconstructionModel(1,rec1);
-  }
-  iDetType=DetType(2);
-  if (!iDetType->GetReconstructionModel()) {
-      AliITSsegmentation *seg2=
-                    (AliITSsegmentation*)iDetType->GetSegmentationModel();
-
-      TClonesArray *dig2=DigitsAddress(2);
-      AliITSClusterFinderSSD *rec2= new AliITSClusterFinderSSD(seg2,dig2);
-      SetReconstructionModel(2,rec2);
-  }
+//______________________________________________________________________
+void AliITS::SetSegmentationModel(Int_t id, AliITSsegmentation *seg){
+    //set the segmentation model for the id detector type
 
+    ((AliITSDetType*) fDetTypes->At(id))->SegmentationModel(seg);
 }
-//_____________________________________________________________________________
-
-void AliITS::MakeTreeC(Option_t *option)
-{
-  // create a separate tree to store the clusters
-
-//  cout << "AliITS::MakeTreeC" << endl;
-
-     const char *optC = strstr(option,"C");
-     if (optC && !fTreeC) fTreeC = new TTree("TC","Clusters in ITS");
-     else return;
-
-
-     Int_t buffersize = 4000;
-     char branchname[30];
-
-     const char *det[3] = {"SPD","SDD","SSD"};
+//______________________________________________________________________
+void AliITS::SetSimulationModel(Int_t id, AliITSsimulation *sim){
+    //set the simulation model for the id detector type
 
-     char digclass[40];
-     char clclass[40];
-
-     // one branch for Clusters per type of detector
-     Int_t i;
-     for (i=0; i<kNTYPES ;i++) {
-        AliITSDetType *iDetType=DetType(i); 
-        iDetType->GetClassNames(digclass,clclass);
-       // clusters
-        fCtype->AddAt(new TClonesArray(clclass,1000),i);
-        if (kNTYPES==3) sprintf(branchname,"%sClusters%s",GetName(),det[i]);
-       else  sprintf(branchname,"%sClusters%d",GetName(),i+1);
-       if (fCtype   && fTreeC) {
-          TreeC()->Branch(branchname,&((*fCtype)[i]), buffersize);
-//        cout << "Making Branch " << branchname;
-//        cout << " for Clusters of detector type " << i+1 << endl;
-       }       
-     }
+   ((AliITSDetType*) fDetTypes->At(id))->SimulationModel(sim);
 
 }
+//______________________________________________________________________
+void AliITS::SetReconstructionModel(Int_t id, AliITSClusterFinder *reconst){
+    //set the cluster finder model for the id detector type
 
-//_____________________________________________________________________________
-void AliITS::GetTreeC(Int_t event)
-{
-
-//  cout << "AliITS::GetTreeC" << endl;
-
-  // get the clusters tree for this event and set the branch address
-    char treeName[20];
-    char branchname[30];
-
-    const char *det[3] = {"SPD","SDD","SSD"};
-
-    ResetClusters();
-    if (fTreeC) {
-         delete fTreeC;
-    }
-
-    sprintf(treeName,"TreeC%d",event);
-    fTreeC = (TTree*)gDirectory->Get(treeName);
-
-    TBranch *branch;
-
-    if (fTreeC) {
-        Int_t i;
-       char digclass[40];
-       char clclass[40];
-       for (i=0; i<kNTYPES; i++) {
-
-          AliITSDetType *iDetType=DetType(i); 
-          iDetType->GetClassNames(digclass,clclass);
-          // clusters
-       //PH       if(!(*fCtype)[i]) fCtype->AddAt(new TClonesArray(clclass,1000),i); 
-          if(!fCtype->At(i)) fCtype->AddAt(new TClonesArray(clclass,1000),i); 
-          if (kNTYPES==3) sprintf(branchname,"%sClusters%s",GetName(),det[i]);
-          else  sprintf(branchname,"%sClusters%d",GetName(),i+1);
-          if (fCtype) {
-               branch = fTreeC->GetBranch(branchname);
-                if (branch) branch->SetAddress(&((*fCtype)[i]));
-           }
-       }
-    } else {
-       Error("AliITS::GetTreeC",
-               "cannot find Clusters Tree for event:%d\n",event);
-    }
-
+    ((AliITSDetType*) fDetTypes->At(id))->ReconstructionModel(reconst);
 }
-//_____________________________________________________________________________
-void AliITS::MakeBranch(Option_t* option, const char *file)
-{
-  //
-  // Creates Tree branches for the ITS.
-  //
-  //
-  Int_t buffersize = 4000;
-  char branchname[30];
-  sprintf(branchname,"%s",GetName());
-
-  AliDetector::MakeBranch(option,file);
-
-  const char *cD = strstr(option,"D");
-  const char *cR = strstr(option,"R");
-
-  if (cD) {
-  //
-  // one branch for digits per type of detector
-  //
-   const char *det[3] = {"SPD","SDD","SSD"};
-
-   char digclass[40];
-   char clclass[40];
-
-   Int_t i;
-   for (i=0; i<kNTYPES ;i++) {
-       DetType(i)->GetClassNames(digclass,clclass);
-       // digits
-       //PH       if(!((*fDtype)[i])) fDtype->AddAt(new TClonesArray(digclass,1000),i);
-       if(!(fDtype->At(i))) fDtype->AddAt(new TClonesArray(digclass,1000),i);
-       else ResetDigits(i);
-   }
-
-   for (i=0; i<kNTYPES ;i++) {
-      if (kNTYPES==3) sprintf(branchname,"%sDigits%s",GetName(),det[i]);
-      else  sprintf(branchname,"%sDigits%d",GetName(),i+1);      
-      if (fDtype && gAlice->TreeD()) {
-        MakeBranchInTree(gAlice->TreeD(), 
-                         branchname, &((*fDtype)[i]), buffersize, file);
-//         cout << "Making Branch " << branchname;
-//         cout << " for digits of type "<< i+1 << endl;
-      }        
-    }
-  }
-
-  if (cR) {
-  //
-  // only one branch for rec points for all detector types
-  //
-    sprintf(branchname,"%sRecPoints",GetName());
-    //if(!fRecPoints) fRecPoints=new TClonesArray("AliITSRecPoint",1000);
+//______________________________________________________________________
+void AliITS::SetClasses(Int_t id, const char *digit, const char *cluster){
+    //set the digit and cluster classes to be used for the id detector type
 
-    if (fRecPoints && gAlice->TreeR()) {
-      MakeBranchInTree(gAlice->TreeR(), 
-                               branchname, &fRecPoints, buffersize, file) ;
-//      cout << "Making Branch " << branchname;
-//      cout << " for reconstructed space points" << endl;
-    }
-  }    
+    ((AliITSDetType*) fDetTypes->At(id))->ClassNames(digit,cluster);
 }
-
-//___________________________________________
-void AliITS::SetTreeAddress()
-{
-
-  // Set branch address for the Trees.
-
-
-  char branchname[30];
-  AliDetector::SetTreeAddress();
-
-  const char *det[3] = {"SPD","SDD","SSD"};
-
-  TBranch *branch;
-  TTree *treeD = gAlice->TreeD();
-  TTree *treeR = gAlice->TreeR();
-
-  char digclass[40];
-  char clclass[40];
-
-  Int_t i;
-  if (treeD) {
-      for (i=0; i<kNTYPES; i++) {
-       DetType(i)->GetClassNames(digclass,clclass);
-         // digits
-    //PH        if(!((*fDtype)[i])) fDtype->AddAt(new TClonesArray(digclass,1000),i);
-        if(!(fDtype->At(i))) fDtype->AddAt(new TClonesArray(digclass,1000),i);
-       else ResetDigits(i);
-
-       if (kNTYPES==3) sprintf(branchname,"%sDigits%s",GetName(),det[i]);
-       else  sprintf(branchname,"%sDigits%d",GetName(),i+1);
-       if (fDtype) {
-          branch = treeD->GetBranch(branchname);
-          if (branch) branch->SetAddress(&((*fDtype)[i]));
-       }
-      }
-  }
-
-  if (treeR) {
-    sprintf(branchname,"%sRecPoints",GetName());
-      branch = treeR->GetBranch(branchname);
-      if (branch) branch->SetAddress(&fRecPoints);
-  }
-  
-
+//______________________________________________________________________
+void AliITS::AddHit(Int_t track, Int_t *vol, Float_t *hits){
+    // Add an ITS hit
+    //     The function to add information to the AliITShit class. See the
+    // AliITShit class for a full description. This function allocates the
+    // necessary new space for the hit information and passes the variable
+    // track, and the pointers *vol and *hits to the AliITShit constructor
+    // function.
+
+    TClonesArray &lhits = *fHits;
+    new(lhits[fNhits++]) AliITShit(fIshunt,track,vol,hits);
 }
-
-//____________________________________________________________________________
+//______________________________________________________________________
 void AliITS::InitModules(Int_t size,Int_t &nmodules){
+    //initialize the modules array
 
-  //initialize the modules array
-
-  if(fITSmodules){ 
-      fITSmodules->Delete();
-      delete fITSmodules;
-  }
+    if(fITSmodules){ 
+       fITSmodules->Delete();
+       delete fITSmodules;
+    } // end fir fITSmoudles
 
     Int_t nl,indexMAX,index;
 
     if(size<=0){ // default to using data stored in AliITSgeom
        if(fITSgeom==0) {
            Error("AliITS::InitModules",
-               "in AliITS::InitModule fITSgeom not defined\n");
+                 "in AliITS::InitModule fITSgeom not defined\n");
            return;
        } // end if fITSgeom==0
        nl = fITSgeom->GetNlayers();
@@ -1042,40 +670,33 @@ void AliITS::InitModules(Int_t size,Int_t &nmodules){
        nmodules = indexMAX;
        fITSmodules = new TObjArray(indexMAX);
        for(index=0;index<indexMAX;index++){
-               fITSmodules->AddAt( new AliITSmodule(index),index);
+           fITSmodules->AddAt( new AliITSmodule(index),index);
        } // end for index
     }else{
        fITSmodules = new TObjArray(size);
        for(index=0;index<size;index++) {
            fITSmodules->AddAt( new AliITSmodule(index),index);
-       }
+       } // end for index
 
         nmodules = size;
     } // end i size<=0
 }
-
-//____________________________________________________________________________
-void AliITS::FillModules(Int_t evnt,Int_t bgrev,Int_t nmodules,Option_t *option,Text_t *filename){
-
-  // fill the modules with the sorted by module hits; add hits from background
-  // if option=Add
-
-
+//______________________________________________________________________
+void AliITS::FillModules(Int_t evnt,Int_t bgrev,Int_t nmodules,
+                        Option_t *option,Text_t *filename){
+    // fill the modules with the sorted by module hits; add hits from
+    // background if option=Add
     static TTree *trH1;                 //Tree with background hits
     static TClonesArray *fHits2;        //List of hits for one track only
-
     static Bool_t first=kTRUE;
     static TFile *file;
     const char *addBgr = strstr(option,"Add");
 
-
     if (addBgr ) {
        if(first) {
-//         cout<<"filename "<<filename<<endl;
            file=new TFile(filename);
-//         cout<<"I have opened "<<filename<<" file "<<endl;
            fHits2     = new TClonesArray("AliITShit",1000  );
-       }           
+       } // end if first
        first=kFALSE;
        file->cd();
        file->ls();
@@ -1083,16 +704,14 @@ void AliITS::FillModules(Int_t evnt,Int_t bgrev,Int_t nmodules,Option_t *option,
        if(fHits2) fHits2->Clear();
        if(trH1) delete trH1;
        trH1=0;
-       
+
        char treeName[20];
        sprintf(treeName,"TreeH%d",bgrev);
        trH1 = (TTree*)gDirectory->Get(treeName);
-        //printf("TrH1 %p of treename %s for event %d \n",trH1,treeName,bgrev);
-       
        if (!trH1) {
-           Error("AliITS::FillModules",
-           "cannot find Hits Tree for event:%d\n",bgrev);
-       }
+           Error("AliITS::FillModules","cannot find Hits Tree for event:%d\n",
+                 bgrev);
+       } // end if !trH1
        // Set branch addresses
        TBranch *branch;
        char branchname[20];
@@ -1100,29 +719,20 @@ void AliITS::FillModules(Int_t evnt,Int_t bgrev,Int_t nmodules,Option_t *option,
        if (trH1 && fHits2) {
            branch = trH1->GetBranch(branchname);
            if (branch) branch->SetAddress(&fHits2);
-       }
+       } // end if trH1 && fHits
+    } // end if addBgr
 
-        // test
-       //Int_t ntracks1 =(Int_t)TrH1->GetEntries();
-       //printf("background - ntracks1 - %d\n",ntracks1);
-   }
-
-    //Int_t npart = gAlice->GetEvent(evnt);
-    //if(npart<=0) return;
     TClonesArray *itsHits = this->Hits();
     Int_t lay,lad,det,index;
     AliITShit *itsHit=0;
     AliITSmodule *mod=0;
-
     TTree *iTH = gAlice->TreeH();
     Int_t ntracks =(Int_t) iTH->GetEntries();
-
     Int_t t,h;
     for(t=0; t<ntracks; t++){
        gAlice->ResetHits();
        iTH->GetEvent(t);
        Int_t nhits = itsHits->GetEntriesFast();
-       //printf("nhits %d\n",nhits);
         if (!nhits) continue;
        for(h=0; h<nhits; h++){
            itsHit = (AliITShit *)itsHits->UncheckedAt(h);
@@ -1139,292 +749,668 @@ void AliITS::FillModules(Int_t evnt,Int_t bgrev,Int_t nmodules,Option_t *option,
     // open the file with background
     
     if (addBgr ) {
-          Int_t track,i;
-          ntracks =(Int_t)trH1->GetEntries();
-           //printf("background - ntracks1 %d\n",ntracks);
-           //printf("background - Start loop over tracks \n");     
-            //   Loop over tracks
-
-           for (track=0; track<ntracks; track++) {
-
-               if (fHits2)       fHits2->Clear();
-               trH1->GetEvent(track);
-                //   Loop over hits
-               for(i=0;i<fHits2->GetEntriesFast();++i) {
-
-                   itsHit=(AliITShit*) (*fHits2)[i];
-                   itsHit->GetDetectorID(lay,lad,det);
-                   // temporarily index=det-1 !!!
-                   if(fITSgeom) index = fITSgeom->GetModuleIndex(lay,lad,det);
-                   else index=det-1;
-                   //
-                   mod = this->GetModule(index);
-                   mod->AddHit(itsHit,track,i);
-              }  // end loop over hits
-           } // end loop over tracks
-
-           TTree *fAli=gAlice->TreeK();
-            TFile *fileAli=0;
-           
-           if (fAli) fileAli =fAli->GetCurrentFile();
-           fileAli->cd();
-
+       Int_t track,i;
+       ntracks =(Int_t)trH1->GetEntries();     
+       // Loop over tracks
+       for (track=0; track<ntracks; track++) {
+           if (fHits2)       fHits2->Clear();
+           trH1->GetEvent(track);
+           //   Loop over hits
+           for(i=0;i<fHits2->GetEntriesFast();++i) {
+               itsHit=(AliITShit*) (*fHits2)[i];
+               itsHit->GetDetectorID(lay,lad,det);
+               // temporarily index=det-1 !!!
+               if(fITSgeom) index = fITSgeom->GetModuleIndex(lay,lad,det);
+               else index=det-1;
+               //
+               mod = this->GetModule(index);
+               mod->AddHit(itsHit,track,i);
+           }  // end loop over hits
+       } // end loop over tracks
+       TTree *fAli=gAlice->TreeK();
+       TFile *fileAli=0;
+       if (fAli) fileAli =fAli->GetCurrentFile();
+       fileAli->cd();
     } // end if add
-
-    //gObjectTable->Print();
-
 }
+//______________________________________________________________________
+void AliITS::ClearModules(){
+    //clear the modules TObjArray
 
-//____________________________________________________________________________
-
-void AliITS::SDigits2Digits()
-{
+    if(fITSmodules) fITSmodules->Delete();
+}
+//______________________________________________________________________
+void AliITS::MakeBranchS(const char *file){
+    // Creates Tree branche for the ITS summable digits.
+    Int_t buffersize = 4000;
+    char branchname[30];
 
-  cerr<<"Digitizing ITS...\n";
+    // only one branch for SDigits.
+    sprintf(branchname,"%s",GetName());
+    if(fSDigits && gAlice->TreeS()){
+       MakeBranchInTree(gAlice->TreeS(),branchname,&fSDigits,buffersize,file);
+    } // end if
+}
+//______________________________________________________________________
+void AliITS::SetTreeAddressS(TTree *treeS){
+    // Set branch address for the ITS summable digits Trees.
+    char branchname[30];
 
-  TStopwatch timer;
-  timer.Start();
-  AliHeader *header=gAlice->GetHeader();
-  HitsToDigits(header->GetEvent(),0,-1," ","All"," ");
-  timer.Stop(); timer.Print();
+    if(!treeS) return;
+    TBranch *branch;
+    sprintf(branchname,"%s",GetName());
+    branch = treeS->GetBranch(branchname);
+    if (branch) branch->SetAddress(&fSDigits);
+}
+//______________________________________________________________________
+void AliITS::MakeBranchD(const char *file){
+    // Creates Tree branches for the ITS.
+    Int_t buffersize = 4000;
+    char branchname[30];
 
+    sprintf(branchname,"%s",GetName());
+    // one branch for digits per type of detector
+    const char *det[3] = {"SPD","SDD","SSD"};
+    char digclass[40];
+    char clclass[40];
+    Int_t i;
+    for (i=0; i<kNTYPES ;i++) {
+       DetType(i)->GetClassNames(digclass,clclass);
+       // digits
+       if(!(fDtype->At(i))) fDtype->AddAt(new TClonesArray(digclass,1000),i);
+       else ResetDigits(i);
+    } // end for i
+    for (i=0; i<kNTYPES ;i++) {
+       if (kNTYPES==3) sprintf(branchname,"%sDigits%s",GetName(),det[i]);
+       else  sprintf(branchname,"%sDigits%d",GetName(),i+1);      
+       if (fDtype && gAlice->TreeD()) {
+           MakeBranchInTree(gAlice->TreeD(), 
+                            branchname, &((*fDtype)[i]),buffersize,file);
+       } // end if
+    } // end for i
 }
+//______________________________________________________________________
+void AliITS::SetTreeAddressD(TTree *treeD){
+    // Set branch address for the Trees.
+    char branchname[30];
+    const char *det[3] = {"SPD","SDD","SSD"};
+    TBranch *branch;
+    char digclass[40];
+    char clclass[40];
+    Int_t i;
 
+    if(!treeD) return;
+    for (i=0; i<kNTYPES; i++) {
+       DetType(i)->GetClassNames(digclass,clclass);
+       // digits
+       if(!(fDtype->At(i))) fDtype->AddAt(new TClonesArray(digclass,1000),i);
+       else ResetDigits(i);
+       if (kNTYPES==3) sprintf(branchname,"%sDigits%s",GetName(),det[i]);
+       else  sprintf(branchname,"%sDigits%d",GetName(),i+1);
+       if (fDtype) {
+           branch = treeD->GetBranch(branchname);
+           if (branch) branch->SetAddress(&((*fDtype)[i]));
+       } // end if fDtype
+    } // end for i
+}
+//______________________________________________________________________
+void AliITS::Hits2SDigits(){
+    // Standard Hits to summable Digits function.
+
+    return; // Using Hits inplace of the larger sDigits.
+    AliHeader *header=gAlice->GetHeader(); // Get event number from this file.
+    // Do the Hits to Digits operation. Use Standard input values.
+    // Event number from file, no background hit merging , use size from
+    // AliITSgeom class, option="All", input from this file only.
+    HitsToSDigits(header->GetEvent(),0,-1," ","All"," ");
+}
+//______________________________________________________________________
+void AliITS::Hits2PreDigits(){
+    // Standard Hits to summable Digits function.
+
+    AliHeader *header=gAlice->GetHeader(); // Get event number from this file.
+    // Do the Hits to Digits operation. Use Standard input values.
+    // Event number from file, no background hit merging , use size from
+    // AliITSgeom class, option="All", input from this file only.
+    HitsToPreDigits(header->GetEvent(),0,-1," ","All"," ");
+}
+//______________________________________________________________________
+void AliITS::SDigits2Digits(){
+    // Standard Summable digits to Digits function.
 
-//____________________________________________________________________________
-void AliITS::HitsToDigits(Int_t evNumber,Int_t bgrev,Int_t size, Option_t *option, Option_t *opt,Text_t *filename)
-{
+    Hits2Digits();
+}
+//______________________________________________________________________
+void AliITS::Hits2Digits(){
+    // Standard Hits to Digits function.
+
+    AliHeader *header=gAlice->GetHeader(); // Get event number from this file.
+    // Do the Hits to Digits operation. Use Standard input values.
+    // Event number from file, no background hit merging , use size from
+    // AliITSgeom class, option="All", input from this file only.
+    HitsToDigits(header->GetEvent(),0,-1," ","All"," ");
+}
+//______________________________________________________________________
+void AliITS::HitsToSDigits(Int_t evNumber,Int_t bgrev,Int_t size,
+                         Option_t *option, Option_t *opt,Text_t *filename){
     // keep galice.root for signal and name differently the file for 
     // background when add! otherwise the track info for signal will be lost !
-  
-   // the condition below will disappear when the geom class will be
-   // initialised for all versions - for the moment it is only for v5 !
-   // 7 is the SDD beam test version  
-   Int_t ver = this->IsVersion(); 
-   if(ver!=5 && ver!=7 && ver!=8 && ver!=9) return; 
-
-   const char *all = strstr(opt,"All");
-   const char *det[3] = {strstr(opt,"SPD"),strstr(opt,"SDD"),strstr(opt,"SSD")};
-
-   static Bool_t setDef=kTRUE;
-   if (setDef) SetDefaultSimulation();
-   setDef=kFALSE;
-
-
-//   cout<<" 1 AliITS "<<endl;
-   Int_t nmodules;
-   InitModules(size,nmodules); 
-//   cout<<" 2 AliITS "<<endl;
-   FillModules(evNumber,bgrev,nmodules,option,filename);
-//   cout<<" 3 AliITS "<<endl;
-
-   //TBranch *branch;
-   AliITSsimulation* sim;
-   //TObjArray *branches=gAlice->TreeD()->GetListOfBranches();
-   AliITSgeom *geom = GetITSgeom();
-
-   Int_t id,module;
-//   Int_t lay, lad, detect;
-   Int_t first,last;
-   for (id=0;id<kNTYPES;id++) {
+    // the condition below will disappear when the geom class will be
+    // initialised for all versions - for the moment it is only for v5 !
+    // 7 is the SDD beam test version
+    return; // using Hits instead of the larger sdigits.
+}
+//______________________________________________________________________
+void AliITS::HitsToPreDigits(Int_t evNumber,Int_t bgrev,Int_t size,
+                         Option_t *option, Option_t *opt,Text_t *filename){
+    // keep galice.root for signal and name differently the file for 
+    // background when add! otherwise the track info for signal will be lost !
+    // the condition below will disappear when the geom class will be
+    // initialised for all versions - for the moment it is only for v5 !
+    // 7 is the SDD beam test version
+
+    if(!GetITSgeom()) return; // need transformations to do digitization.
+    AliITSgeom *geom = GetITSgeom();
+
+    const char *all = strstr(opt,"All");
+    const char *det[3] = {strstr(opt,"SPD"),strstr(opt,"SDD"),
+                         strstr(opt,"SSD")};
+    static Bool_t setDef=kTRUE;
+    if (setDef) SetDefaultSimulation();
+    setDef=kFALSE;
+
+    Int_t nmodules;
+    InitModules(size,nmodules);
+    FillModules(evNumber,bgrev,nmodules,option,filename);
+
+    AliITSsimulation *sim      = 0;
+    AliITSDetType    *iDetType = 0;
+    AliITSmodule     *mod      = 0;
+    Int_t id,module;
+    for(module=0;module<geom->GetIndexMax();module++){
+       id       = geom->GetModuleType(module);
+        if (!all && !det[id]) continue;
+       iDetType = DetType(id);
+       sim      = (AliITSsimulation*)iDetType->GetSimulationModel();
+       if (!sim) {
+           Error("HitsToSDigits",
+                 "The simulation class was not instantiated!");
+           exit(1);
+       } // end if !sim
+       mod      = (AliITSmodule *)fITSmodules->At(module);
+       sim->SDigitiseModule(mod,module,evNumber);
+       // fills all branches - wasted disk space
+       gAlice->TreeS()->Fill(); 
+       ResetSDigits();
+    } // end for module
+
+    ClearModules();
+
+    gAlice->TreeS()->GetEntries();
+
+    char hname[30];
+    sprintf(hname,"TreeS%d",evNumber);
+    gAlice->TreeS()->Write(hname,TObject::kOverwrite);
+    // reset tree
+    gAlice->TreeS()->Reset();
+}
+//______________________________________________________________________
+void AliITS::HitsToDigits(Int_t evNumber,Int_t bgrev,Int_t size,
+                         Option_t *option, Option_t *opt,Text_t *filename){
+    // keep galice.root for signal and name differently the file for 
+    // background when add! otherwise the track info for signal will be lost !
+    // the condition below will disappear when the geom class will be
+    // initialised for all versions - for the moment it is only for v5 !
+    // 7 is the SDD beam test version  
+/*    Int_t ver = this->IsVersion(); 
+    if(ver!=5 && ver!=7 && ver!=8 && ver!=9) return; 
+*/
+    if(!GetITSgeom()) return; // need transformations to do digitization.
+    AliITSgeom *geom = GetITSgeom();
+
+    const char *all = strstr(opt,"All");
+    const char *det[3] = {strstr(opt,"SPD"),strstr(opt,"SDD"),
+                         strstr(opt,"SSD")};
+    static Bool_t setDef=kTRUE;
+    if (setDef) SetDefaultSimulation();
+    setDef=kFALSE;
+
+    Int_t nmodules;
+    InitModules(size,nmodules);
+    FillModules(evNumber,bgrev,nmodules,option,filename);
+
+    AliITSsimulation *sim      = 0;
+    AliITSDetType    *iDetType = 0;
+    AliITSmodule     *mod      = 0;
+    Int_t id,module;
+    for(module=0;module<geom->GetIndexMax();module++){
+       id       = geom->GetModuleType(module);
+        if (!all && !det[id]) continue;
+       iDetType = DetType(id);
+       sim      = (AliITSsimulation*)iDetType->GetSimulationModel();
+       if (!sim) {
+           Error("HitsToDigits",
+                 "The simulation class was not instantiated!");
+           exit(1);
+       } // end if !sim
+       mod      = (AliITSmodule *)fITSmodules->At(module);
+       sim->DigitiseModule(mod,module,evNumber);
+       // fills all branches - wasted disk space
+       gAlice->TreeD()->Fill(); 
+       ResetDigits();
+    } // end for module
+/*
+    Int_t id,module;
+    Int_t first,last;
+    for (id=0;id<kNTYPES;id++) {
         if (!all && !det[id]) continue;
-       //branch = (TBranch*)branches->UncheckedAt(id);
        AliITSDetType *iDetType=DetType(id); 
        sim = (AliITSsimulation*)iDetType->GetSimulationModel();
        if(geom) {
-         first = geom->GetStartDet(id);
-         last = geom->GetLastDet(id);
+           first = geom->GetStartDet(id);
+           last = geom->GetLastDet(id);
        } else first=last=0;
-       printf("first module - last module %d %d\n",first,last);
        for(module=first;module<=last;module++) {
            AliITSmodule *mod = (AliITSmodule *)fITSmodules->At(module);
            sim->DigitiseModule(mod,module,evNumber);
            // fills all branches - wasted disk space
            gAlice->TreeD()->Fill(); 
            ResetDigits();
-           // try and fill only the branch 
-           //branch->Fill();
-           //ResetDigits(id);
        } // loop over modules
-   } // loop over detector types
-
-   ClearModules();
+    } // loop over detector types
+*/
+    ClearModules();
 
-//   Int_t nentries=(Int_t)
-   gAlice->TreeD()->GetEntries();
-//   cout << "nentries in TreeD" << nentries << endl;
+    gAlice->TreeD()->GetEntries();
 
-   char hname[30];
-   sprintf(hname,"TreeD%d",evNumber);
-   gAlice->TreeD()->Write(hname,TObject::kOverwrite);
-   // reset tree
-   gAlice->TreeD()->Reset();
+    char hname[30];
+    sprintf(hname,"TreeD%d",evNumber);
+    gAlice->TreeD()->Write(hname,TObject::kOverwrite);
+    // reset tree
+    gAlice->TreeD()->Reset();
+}
+//______________________________________________________________________
+void AliITS::ResetSDigits(){
+    // Reset the Summable Digits array
 
+    if (fSDigits) fSDigits->Clear();
+    fNSDigits = 0;
 }
+//______________________________________________________________________
+void AliITS::ResetDigits(){
+    // Reset number of digits and the digits array for the ITS detector
 
+    if (!fDtype) return;
 
-//_____________________________________________________________________________
-void AliITS::Digits2Reco()
-{
-  // find clusters and reconstruct space points
+    Int_t i;
+    for (i=0;i<kNTYPES;i++ ) {
+       if (fDtype->At(i))    ((TClonesArray*)fDtype->At(i))->Clear();
+       if (fNdtype)  fNdtype[i]=0;
+    } // end for i
+}
+//______________________________________________________________________
+void AliITS::ResetDigits(Int_t i){
+    // Reset number of digits and the digits array for this branch
 
-  AliHeader *header=gAlice->GetHeader();
-  printf("header->GetEvent() %d\n",header->GetEvent());
-  DigitsToRecPoints(header->GetEvent(),0,"All");
+    if (fDtype->At(i))    ((TClonesArray*)fDtype->At(i))->Clear();
+    if (fNdtype)  fNdtype[i]=0;
+}
+//______________________________________________________________________
+void AliITS::AddSumDigit(AliITSpListItem &sdig){
+    // adds the a module full of summable digits to the summable digits tree.
 
+    TClonesArray &lsdig = *fSDigits;
+    new(lsdig[fNSDigits++]) AliITSpListItem(sdig);
 }
-//____________________________________________________________________________
-void AliITS::DigitsToRecPoints(Int_t evNumber,Int_t lastentry,Option_t *opt)
-{
-  // cluster finding and reconstruction of space points
-  
-   // the condition below will disappear when the geom class will be
-   // initialised for all versions - for the moment it is only for v5 !
-   // 7 is the SDD beam test version  
-   Int_t ver = this->IsVersion(); 
-   if(ver!=5 && ver!=8 && ver!=9) return;
+//______________________________________________________________________
+void AliITS::AddRealDigit(Int_t id, Int_t *digits){
+    // add a real digit - as coming from data
 
-   const char *all = strstr(opt,"All");
-   const char *det[3] = {strstr(opt,"SPD"),strstr(opt,"SDD"),strstr(opt,"SSD")};
+    TClonesArray &ldigits = *((TClonesArray*)fDtype->At(id));
+    new(ldigits[fNdtype[id]++]) AliITSdigit(digits);
+}
+//______________________________________________________________________
+void AliITS::AddSimDigit(Int_t id, AliITSdigit *d){
+    // add a simulated digit
+
+    TClonesArray &ldigits = *((TClonesArray*)fDtype->At(id));
+
+    switch(id){
+    case 0:
+       new(ldigits[fNdtype[id]++]) AliITSdigitSPD(*((AliITSdigitSPD*)d));
+       break;
+    case 1:
+       new(ldigits[fNdtype[id]++]) AliITSdigitSDD(*((AliITSdigitSDD*)d));
+       break;
+    case 2:
+       new(ldigits[fNdtype[id]++]) AliITSdigitSSD(*((AliITSdigitSSD*)d));
+       break;
+    } // end switch id
+}
+//______________________________________________________________________
+void AliITS::AddSimDigit(Int_t id,Float_t phys,Int_t *digits,Int_t *tracks,
+                        Int_t *hits,Float_t *charges){
+    // add a simulated digit to the list
+
+    TClonesArray &ldigits = *((TClonesArray*)fDtype->At(id));
+    switch(id){
+    case 0:
+       new(ldigits[fNdtype[id]++]) AliITSdigitSPD(digits,tracks,hits);
+       break;
+    case 1:
+       new(ldigits[fNdtype[id]++]) AliITSdigitSDD(phys,digits,tracks,
+                                                  hits,charges);
+       break;
+    case 2:
+       new(ldigits[fNdtype[id]++]) AliITSdigitSSD(digits,tracks,hits);
+       break;
+    } // end switch id
+}
+//______________________________________________________________________
+void AliITS::MakeTreeC(Option_t *option){
+    // create a separate tree to store the clusters
 
-   static Bool_t setRec=kTRUE;
-   if (setRec) SetDefaultClusterFinders();
-   setRec=kFALSE;
+    const char *optC = strstr(option,"C");
+    if (optC && !fTreeC) fTreeC = new TTree("TC","Clusters in ITS");
+    else return;
 
+    Int_t buffersize = 4000;
+    char branchname[30];
+    const char *det[3] = {"SPD","SDD","SSD"};
+    char digclass[40];
+    char clclass[40];
 
-   TTree *treeC=TreeC();
+    // one branch for Clusters per type of detector
+    Int_t i;
+    for (i=0; i<kNTYPES ;i++) {
+        AliITSDetType *iDetType=DetType(i); 
+        iDetType->GetClassNames(digclass,clclass);
+       // clusters
+        fCtype->AddAt(new TClonesArray(clclass,1000),i);
+        if (kNTYPES==3) sprintf(branchname,"%sClusters%s",GetName(),det[i]);
+       else  sprintf(branchname,"%sClusters%d",GetName(),i+1);
+       if (fCtype   && fTreeC) {
+           TreeC()->Branch(branchname,&((*fCtype)[i]), buffersize);
+       } // end if fCtype && fTreeC
+    } // end for i
+}
+//______________________________________________________________________
+void AliITS::GetTreeC(Int_t event){
+    // get the clusters tree for this event and set the branch address
+    char treeName[20];
+    char branchname[30];
+    const char *det[3] = {"SPD","SDD","SSD"};
 
-   //TBranch *branch;
-   AliITSClusterFinder* rec;
+    ResetClusters();
+    if (fTreeC) {
+       delete fTreeC;
+    } // end if fTreeC
 
-   //TObjArray *branches=gAlice->TreeR()->GetListOfBranches();
-   AliITSgeom *geom = GetITSgeom();
+    sprintf(treeName,"TreeC%d",event);
+    fTreeC = (TTree*)gDirectory->Get(treeName);
 
-   Int_t id,module;
-   for (id=0;id<kNTYPES;id++) {
-        if (!all && !det[id]) continue;
-       //branch = (TBranch*)branches->UncheckedAt(id);
-       AliITSDetType *iDetType=DetType(id); 
-       rec = (AliITSClusterFinder*)iDetType->GetReconstructionModel();
-        TClonesArray *itsDigits  = this->DigitsAddress(id);
-        Int_t first,last;
-       if(geom) {
-         first = geom->GetStartDet(id);
-         last = geom->GetLastDet(id);
-       } else first=last=0;
-       printf("first module - last module %d %d\n",first,last);
-       for(module=first;module<=last;module++) {
-              this->ResetDigits();
-              if (all) gAlice->TreeD()->GetEvent(lastentry+module);
-             else gAlice->TreeD()->GetEvent(lastentry+(module-first));
-             Int_t ndigits = itsDigits->GetEntriesFast();
-             if (ndigits) rec->FindRawClusters(module);
-             gAlice->TreeR()->Fill(); 
-             ResetRecPoints();
-             treeC->Fill();
-              ResetClusters();
-             // try and fill only the branch 
-             //branch->Fill();
-             //ResetRecPoints(id);
-       } // loop over modules
-   } // loop over detector types
+    TBranch *branch;
+
+    if (fTreeC) {
+        Int_t i;
+       char digclass[40];
+       char clclass[40];
+       for (i=0; i<kNTYPES; i++) {
+           AliITSDetType *iDetType=DetType(i); 
+           iDetType->GetClassNames(digclass,clclass);
+           // clusters
+           if(!fCtype->At(i)) fCtype->AddAt(new TClonesArray(clclass,1000),i);
+           if(kNTYPES==3) sprintf(branchname,"%sClusters%s",GetName(),det[i]);
+           else  sprintf(branchname,"%sClusters%d",GetName(),i+1);
+           if (fCtype) {
+               branch = fTreeC->GetBranch(branchname);
+                if (branch) branch->SetAddress(&((*fCtype)[i]));
+           } // end if fCtype
+       } // end for i
+    } else {
+       Error("AliITS::GetTreeC",
+             "cannot find Clusters Tree for event:%d\n",event);
+    } // end if fTreeC
+}
+//______________________________________________________________________
+void AliITS::AddCluster(Int_t id, AliITSRawCluster *c){
+    // add a cluster to the list
+
+    TClonesArray &lc = *((TClonesArray*)fCtype->At(id));
+
+    switch(id){
+    case 0:
+       new(lc[fNctype[id]++]) AliITSRawClusterSPD(*((AliITSRawClusterSPD*)c));
+       break;
+    case 1:
+       new(lc[fNctype[id]++]) AliITSRawClusterSDD(*((AliITSRawClusterSDD*)c));
+       break;
+    case 2:
+       new(lc[fNctype[id]++]) AliITSRawClusterSSD(*((AliITSRawClusterSSD*)c));
+       break;
+    } // end switch id
+}
+//______________________________________________________________________
+void AliITS::ResetClusters(){
+    // Reset number of clusters and the clusters array for ITS
+
+    Int_t i;
+    for (i=0;i<kNTYPES;i++ ) {
+       if (fCtype->At(i))    ((TClonesArray*)fCtype->At(i))->Clear();
+       if (fNctype)  fNctype[i]=0;
+    } // end for i
+}
+//______________________________________________________________________
+void AliITS::ResetClusters(Int_t i){
+    // Reset number of clusters and the clusters array for this branch
 
+    if (fCtype->At(i))    ((TClonesArray*)fCtype->At(i))->Clear();
+    if (fNctype)  fNctype[i]=0;
+}
+//______________________________________________________________________
+void AliITS::MakeBranchR(const char *file){
+    // Creates Tree branches for the ITS Reconstructed points.
+    Int_t buffersize = 4000;
+    char branchname[30];
 
-//   Int_t nentries=(Int_t)
-   gAlice->TreeR()->GetEntries();
-//   Int_t ncentries=(Int_t)
-   treeC->GetEntries();
-//   cout << " nentries ncentries " << nentries << ncentries <<  endl;
+//    sprintf(branchname,"%s",GetName());
+    // only one branch for rec points for all detector types
+    sprintf(branchname,"%sRecPoints",GetName());
+    if (fRecPoints && gAlice->TreeR()) {
+       MakeBranchInTree(gAlice->TreeR(),branchname, &fRecPoints,
+                        buffersize,file) ;
+    } // end if
+}
+//______________________________________________________________________
+void AliITS::SetTreeAddressR(TTree *treeR){
+    // Set branch address for the Reconstructed points Trees.
+    char branchname[30];
 
-   char hname[30];
-   sprintf(hname,"TreeR%d",evNumber);
-   gAlice->TreeR()->Write(hname,TObject::kOverwrite);
-   // reset tree
-   gAlice->TreeR()->Reset();
+    if(!treeR) return;
+    TBranch *branch;
+//    sprintf(branchname,"%s",GetName());
+    sprintf(branchname,"%sRecPoints",GetName());
+    branch = treeR->GetBranch(branchname);
+    if (branch) branch->SetAddress(&fRecPoints);
+}
+//______________________________________________________________________
+void AliITS::AddRecPoint(const AliITSRecPoint &r){
+    // Add a reconstructed space point to the list
 
-   sprintf(hname,"TreeC%d",evNumber);
-   treeC->Write(hname,TObject::kOverwrite);
-   treeC->Reset();
+    TClonesArray &lrecp = *fRecPoints;
+    new(lrecp[fNRecPoints++]) AliITSRecPoint(r);
 }
-//____________________________________________________________________________
+//______________________________________________________________________
 void AliITS::HitsToFastRecPoints(Int_t evNumber,Int_t bgrev,Int_t size,
-Option_t *option,Option_t *opt,Text_t *filename)
-{
+                                Option_t *opt0,Option_t *opt1,Text_t *flnm){
     // keep galice.root for signal and name differently the file for 
     // background when add! otherwise the track info for signal will be lost !
-  
-
-   // the condition below will disappear when the geom class will be
-   // initialised for all versions - for the moment it is only for v5 !  
-   Int_t ver = this->IsVersion(); 
-   if(ver!=5 && ver!=8 && ver!=9) return;
-
-
-   const char *all = strstr(opt,"All");
-   const char *det[3] ={strstr(opt,"SPD"),strstr(opt,"SDD"),strstr(opt,"SSD")};
-
-   Int_t nmodules;
-   InitModules(size,nmodules);
-   FillModules(evNumber,bgrev,nmodules,option,filename);
-
-
-   AliITSsimulation* sim;
-   AliITSgeom *geom = GetITSgeom();
-/* MI change 
-   TRandom *random=new TRandom[9];
-   random[0].SetSeed(111);
-   random[1].SetSeed(222);
-   random[2].SetSeed(333);             
-   random[3].SetSeed(444);
-   random[4].SetSeed(555);
-   random[5].SetSeed(666);             
-   random[6].SetSeed(777);
-   random[7].SetSeed(888);
-   random[8].SetSeed(999);             
-   */
-
-   Int_t id,module;
-   for (id=0;id<kNTYPES;id++) {
+    // the condition below will disappear when the geom class will be
+    // initialised for all versions - for the moment it is only for v5 !
+/*    Int_t ver = this->IsVersion(); 
+    if(ver!=5 && ver!=8 && ver!=9) return;
+*/
+    if(!GetITSgeom()) return;
+    AliITSgeom *geom = GetITSgeom();
+
+    const char *all = strstr(opt1,"All");
+    const char *det[3] ={strstr(opt1,"SPD"),strstr(opt1,"SDD"),
+                        strstr(opt1,"SSD")};
+    Int_t nmodules;
+    InitModules(size,nmodules);
+    FillModules(evNumber,bgrev,nmodules,opt0,flnm);
+
+    AliITSsimulation *sim      = 0;
+    AliITSDetType    *iDetType = 0;
+    AliITSmodule     *mod      = 0;
+    Int_t id,module;
+    for(module=0;module<geom->GetIndexMax();module++){
+       id       = geom->GetModuleType(module);
+        if (!all && !det[id]) continue;
+       iDetType = DetType(id);
+       sim      = (AliITSsimulation*)iDetType->GetSimulationModel();
+       if (!sim) {
+           Error("HitsToFastPoints",
+                 "The simulation class was not instantiated!");
+           exit(1);
+       } // end if !sim
+       mod      = (AliITSmodule *)fITSmodules->At(module);
+       sim->CreateFastRecPoints(mod,module,gRandom);
+       // fills all branches - wasted disk space
+       gAlice->TreeD()->Fill(); 
+       ResetDigits();
+    } // end for module
+/*
+    Int_t id,module;
+    for (id=0;id<kNTYPES;id++) {
         if (!all && !det[id]) continue;
        AliITSDetType *iDetType=DetType(id); 
        sim = (AliITSsimulation*)iDetType->GetSimulationModel();
        if (!sim) {
-           Error("HitsToFastPoints",
-                "The simulation class was not instantiated!");
-           exit(1);
-          // or SetDefaultSimulation();
-       }
-
+           Error("HitsToFastPoints",
+                 "The simulation class was not instantiated!");
+           exit(1);
+       } // end if !sim
         Int_t first,last;
         if(geom) {
-         first = geom->GetStartDet(id);
-         last = geom->GetLastDet(id);
+           first = geom->GetStartDet(id);
+           last = geom->GetLastDet(id);
         } else first=last=0;
-        printf("first module - last module %d %d\n",first,last);
        for(module=first;module<=last;module++) {
            AliITSmodule *mod = (AliITSmodule *)fITSmodules->At(module);
-        // sim->CreateFastRecPoints(mod,module,random);
-        sim->CreateFastRecPoints(mod,module,gRandom); //MI change
-          
+           sim->CreateFastRecPoints(mod,module,gRandom);
            gAlice->TreeR()->Fill(); 
            ResetRecPoints();
        } // loop over modules
-   } // loop over detector types
-
-
-   ClearModules();
-
-   //Int_t nentries=(Int_t)gAlice->TreeR()->GetEntries();
-
-   char hname[30];
-   sprintf(hname,"TreeR%d",evNumber);
-   gAlice->TreeR()->Write(hname,TObject::kOverwrite);
-   // reset tree
-   gAlice->TreeR()->Reset();
-
-   //   delete [] random; //MI change 
+    } // loop over detector types
+*/
+    ClearModules();
 
+    char hname[30];
+    sprintf(hname,"TreeR%d",evNumber);
+    gAlice->TreeR()->Write(hname,TObject::kOverwrite);
+    // reset tree
+    gAlice->TreeR()->Reset();
+}
+//______________________________________________________________________
+void AliITS::Digits2Reco(){
+    // find clusters and reconstruct space points
+
+    AliHeader *header=gAlice->GetHeader();
+    // to Digits to RecPoints for event in file, all digits in file, and
+    // all ITS detectors.
+    DigitsToRecPoints(header->GetEvent(),0,"All");
+}
+//______________________________________________________________________
+void AliITS::DigitsToRecPoints(Int_t evNumber,Int_t lastentry,Option_t *opt){
+    // cluster finding and reconstruction of space points
+    // the condition below will disappear when the geom class will be
+    // initialised for all versions - for the moment it is only for v5 !
+    // 7 is the SDD beam test version  
+/*    Int_t ver = this->IsVersion(); 
+    if(ver!=5 && ver!=8 && ver!=9) return;
+*/
+    if(!GetITSgeom()) return;
+    AliITSgeom *geom = GetITSgeom();
+    
+    const char *all = strstr(opt,"All");
+    const char *det[3] = {strstr(opt,"SPD"),strstr(opt,"SDD"),
+                         strstr(opt,"SSD")};
+    static Bool_t setRec=kTRUE;
+    if (setRec) SetDefaultClusterFinders();
+    setRec=kFALSE;
+
+    TTree *treeC=TreeC();
+
+    AliITSClusterFinder *rec     = 0;
+    AliITSDetType      *iDetType = 0;
+    Int_t id,module,first=0;
+    for(module=0;module<geom->GetIndexMax();module++){
+       id       = geom->GetModuleType(module);
+        if (!all && !det[id]) continue;
+       if(det[id]) first = geom->GetStartDet(id);
+       iDetType = DetType(id);
+       rec = (AliITSClusterFinder*)iDetType->GetReconstructionModel();
+        TClonesArray *itsDigits  = this->DigitsAddress(id);
+       if (!rec) {
+           Error("DigitsToRecPoints",
+                 "The reconstruction class was not instantiated!");
+           exit(1);
+       } // end if !rec
+       this->ResetDigits();
+       if (all) gAlice->TreeD()->GetEvent(lastentry+module);
+       else gAlice->TreeD()->GetEvent(lastentry+(module-first));
+       Int_t ndigits = itsDigits->GetEntriesFast();
+       if (ndigits) rec->FindRawClusters(module);
+       gAlice->TreeR()->Fill(); 
+       ResetRecPoints();
+       treeC->Fill();
+       ResetClusters();
+    } // end for module
 
+/*
+    Int_t id,module;
+    for (id=0;id<kNTYPES;id++) {
+        if (!all && !det[id]) continue;
+       AliITSDetType *iDetType=DetType(id); 
+       rec = (AliITSClusterFinder*)iDetType->GetReconstructionModel();
+        TClonesArray *itsDigits  = this->DigitsAddress(id);
+        Int_t first,last;
+       if(geom) {
+           first = geom->GetStartDet(id);
+           last = geom->GetLastDet(id);
+       } else first=last=0;
+       printf("first module - last module %d %d\n",first,last);
+       for(module=first;module<=last;module++) {
+           this->ResetDigits();
+           if (all) gAlice->TreeD()->GetEvent(lastentry+module);
+           else gAlice->TreeD()->GetEvent(lastentry+(module-first));
+           Int_t ndigits = itsDigits->GetEntriesFast();
+           if (ndigits) rec->FindRawClusters(module);
+           gAlice->TreeR()->Fill(); 
+           ResetRecPoints();
+           treeC->Fill();
+           ResetClusters();
+       } // loop over modules
+    } // loop over detector types
+*/
+    gAlice->TreeR()->GetEntries();
+    treeC->GetEntries();
+
+    char hname[30];
+    sprintf(hname,"TreeR%d",evNumber);
+    gAlice->TreeR()->Write(hname,TObject::kOverwrite);
+    // reset tree
+    gAlice->TreeR()->Reset();
+
+    sprintf(hname,"TreeC%d",evNumber);
+    treeC->Write(hname,TObject::kOverwrite);
+    treeC->Reset();
 }
+//______________________________________________________________________
+void AliITS::ResetRecPoints(){
+    // Reset number of rec points and the rec points array
 
+    if (fRecPoints) fRecPoints->Clear();
+    fNRecPoints = 0;
+}
index 0a54006..f7ba02c 100644 (file)
@@ -24,143 +24,165 @@ class AliITSsegmentation;
 class AliITSresponse;
 class AliITShit;
 class AliITSgeom;
+class AliITSpListItem;
 class AliITSdigit;
 class AliITSRecPoint;
 class AliITSRawCluster;
 class AliITSmodule;
 
-
 const Int_t kNTYPES=3;
 
-
 class AliITS : public AliDetector {
 
-  public:
-                    AliITS();
-                    AliITS(const char *name, const char *title);
-    virtual        ~AliITS();
-    AliITS(AliITS &source);
-    AliITS & operator=(AliITS &source);
-
-    virtual void   AddHit(Int_t track, Int_t *vol, Float_t *hits);
-    virtual void   AddRealDigit(Int_t branch, Int_t *digits);
-    virtual void   AddSimDigit(Int_t branch, AliITSdigit *d);
-    virtual void   AddSimDigit(Int_t branch,Float_t phys,Int_t* digits,Int_t* tracks,Int_t *hits,Float_t* trkcharges); 
-    //
-    virtual void   AddCluster(Int_t branch, AliITSRawCluster *c);
-    virtual void   AddRecPoint(const AliITSRecPoint &p);
-
-    virtual void   ResetDigits();                   // depending on how the
-    virtual void   ResetDigits(Int_t branch);       // tree will be filled only
-    virtual void   ResetClusters();                 // one of the methods in 
-    virtual void   ResetClusters(Int_t branch);     // the pair will be kept
-    virtual void   ResetRecPoints();
-
+ public:
+    //================= Standard Classes ===============================
+    AliITS();  // Default creator.
+    AliITS(const char *name, const char *title); // standard Creator
+    virtual ~AliITS(); // destructor
+    AliITS(AliITS &source); // copy constructor. Not to be used!
+    AliITS& operator=(AliITS &source); // = operator. Not to be used!
+    virtual Int_t IsVersion() const {return 1;}
+    virtual Int_t DistancetoPrimitive(Int_t px, Int_t py);
+
+    //===================== Simulation Geometry ========================
     // get geometry version - detailed (major) or coarse (minor)
-    virtual Int_t  GetMajorVersion(){return -1;}
-    virtual Int_t  GetMinorVersion(){return -1;}
-    void GetGeometryVersion(Int_t &a,Int_t &b) 
-                  {a = GetMajorVersion();b=GetMinorVersion();return;}
-    virtual Int_t  IsVersion() const {return 1;}
-    virtual Int_t  DistancetoPrimitive(Int_t px, Int_t py);
-    virtual void   Init();
-    virtual void   SetDefaults();
-    virtual void   SetDefaultSimulation();
-    virtual void   SetDefaultClusterFinders();
-    // create separate tree for clusters - declustering refining
-    virtual  void  MakeTreeC(Option_t *option="C");
-    void           GetTreeC(Int_t event);
-    virtual void   MakeBranch(Option_t *opt=" ", const char *file=0);
-    void           SetTreeAddress();
-    virtual void   SetEUCLID(Bool_t euclid=1) {fEuclidOut = euclid;}
-    virtual void   StepManager() {}
-    // sort hits by module
-    virtual void   InitModules(Int_t size,Int_t &nmodules);  
-    virtual void   FillModules(Int_t evnt,Int_t bgrev,
-                       Int_t nmodules,Option_t *opt,Text_t *filename);
-    virtual void   ClearModules();
-    // Digitisation
-    virtual void   SDigits2Digits();  
-    void HitsToDigits(Int_t evNumber,Int_t bgrev,Int_t size,
-                 Option_t *add, Option_t *det, Text_t *filename);
-    // Reconstruct hits
-    void Digits2Reco();
-    void DigitsToRecPoints(Int_t evNumber,Int_t lastEntry,Option_t *det);
-    // Fast simulation of space points from hits
-    void HitsToFastRecPoints(Int_t evNumber,Int_t bgrev,Int_t size,
-                 Option_t *add, Option_t *det, Text_t *filename);
-
-    // Write digits into raw data format
-    virtual void Digits2RawData() {}
-    // Decode raw data and store digits
-    virtual void RawData2Digits() {}
+    virtual Int_t GetMajorVersion(){return -1;}
+    virtual Int_t GetMinorVersion(){return -1;}
+    virtual void  GetGeometryVersion(Int_t &a,Int_t &b) 
+                          {a = GetMajorVersion();b=GetMinorVersion();return;}
+    virtual void  SetEUCLID(Bool_t euclid=1) {fEuclidOut = euclid;}
+    //-------------------- Geometry Transformations --------------------
+    // ITS geometry functions
+    AliITSgeom   *GetITSgeom() const {return fITSgeom;}
+    // return pointer to the array of modules
+    TObjArray    *GetModules() const {return fITSmodules;}
+    // return pointer to a particular module
+    AliITSmodule *GetModule(Int_t index) {return (AliITSmodule *)
+                                             (fITSmodules->At(index));}
 
-    // Configuration Methods (per detector type )
+    //================ Nessesary general Classes =======================
+    virtual void Init();
+    virtual void SetDefaults();
+    virtual void SetDefaultSimulation();
+    virtual void SetDefaultClusterFinders();
+    virtual void MakeBranch(Option_t *opt=" ", const char *file=0);
+    virtual void SetTreeAddress();
+    // Return pointer to DetType #id
+    AliITSDetType *DetType(Int_t id);
+    //Int_t           NDetTypes() {return fNDetTypes;}
+    //---------- Configuration Methods (per detector type) -------------
     // Set response 
-    virtual void   SetResponseModel(Int_t id, AliITSresponse *response);
+    virtual void SetResponseModel(Int_t id, AliITSresponse *response);
     // Set segmentation 
-    virtual void   SetSegmentationModel(Int_t id, AliITSsegmentation *seg);
+    virtual void SetSegmentationModel(Int_t id, AliITSsegmentation *seg);
     // Set simulation - temporary 
-    virtual void   SetSimulationModel(Int_t id, AliITSsimulation *sim);
+    virtual void SetSimulationModel(Int_t id, AliITSsimulation *sim);
     // Set reconstruction 
-    virtual void   SetReconstructionModel(Int_t id, AliITSClusterFinder *rec);
+    virtual void SetReconstructionModel(Int_t id, AliITSClusterFinder *rec);
     // Set class names for digit and rec point 
-    virtual void   SetClasses(Int_t id, const char *digit, const char *cluster);
-
+    virtual void SetClasses(Int_t id, const char *digit, const char *cluster);
+
+    //=================== Hits =========================================
+    virtual void StepManager() {} // See Step Manager for specific geometry.
+    virtual void AddHit(Int_t track, Int_t *vol, Float_t *hits);
+    //------------ sort hits by module for Digitisation ----------------
+    virtual void InitModules(Int_t size,Int_t &nmodules);  
+    virtual void FillModules(Int_t evnt,Int_t bgrev,Int_t nmodules,
+                            Option_t *opt,Text_t *filename);
+    virtual void ClearModules();
+
+    //===================== Digitisation ===============================
+    void MakeBranchS(const char *file);
+    void SetTreeAddressS(TTree *treeS);
+    void MakeBranchD(const char *file);
+    void SetTreeAddressD(TTree *treeD);
+    void Hits2SDigits(); // Turn hits into SDigits
+    void Hits2PreDigits(); // Turn hits into SDigits
+    void SDigits2Digits(); // Turn SDigits to Digits
+    void Hits2Digits(); // Turn hits straight into Digits.
+    //------------------ Internal functions ----------------------------
+    // Standard Hits To SDigits function
+    void HitsToSDigits(Int_t evNumber,Int_t bgrev,Int_t size,
+                 Option_t *add, Option_t *det, Text_t *filename);
+    // Standard Hits To SDigits function
+    void HitsToPreDigits(Int_t evNumber,Int_t bgrev,Int_t size,
+                 Option_t *add, Option_t *det, Text_t *filename);
+    // Standard Hits To Digits function
+    void HitsToDigits(Int_t evNumber,Int_t bgrev,Int_t size,
+                 Option_t *add, Option_t *det, Text_t *filename);
+    void ResetSDigits();                  // Resets the Summable digits.
+    void ResetDigits();                   // depending on how the
+    void ResetDigits(Int_t branch);       // tree will be filled only
+    void AddSumDigit(AliITSpListItem &sdig);
+    void AddRealDigit(Int_t branch, Int_t *digits);
+    void AddSimDigit(Int_t branch, AliITSdigit *d);
+    void AddSimDigit(Int_t branch,Float_t phys,Int_t* digits,
+                    Int_t* tracks,Int_t *hits,Float_t* trkcharges);
+    // Return pointers to digits 
+    TObjArray    *Dtype() {return fDtype;}
+    Int_t        *Ndtype() {return fNdtype;}
+    TClonesArray *DigitsAddress(Int_t id)
+       {return ((TClonesArray *) (*fDtype)[id]);}
 
-    // Getters
-    // ITS geometry functions
-    virtual AliITSgeom  *GetITSgeom() const {return fITSgeom;}
-    // return pointer to the array of modules
-    virtual TObjArray   *GetModules() const {return fITSmodules;}
-    // return pointer to a particular module
-    AliITSmodule *GetModule(Int_t index) {return (AliITSmodule *)
-                                             (fITSmodules->At(index));}
+    //===================== Raw Data IO ================================
+    // Write digits into raw data format
+    virtual void Digits2RawData() {}
+    // Decode raw data and store digits
+    virtual void RawData2Digits() {}
 
-    // Return pointers to digits 
-    TObjArray            *Dtype() {return fDtype;}
-    Int_t                *Ndtype() {return fNdtype;}
-    virtual TClonesArray *DigitsAddress(Int_t id) 
-                   {return ((TClonesArray *) (*fDtype)[id]);}
+    //==================== Clusterization ==============================
+    // create separate tree for clusters - declustering refining
+    void MakeTreeC(Option_t *option="C");
+    void GetTreeC(Int_t event);
+    void AddCluster(Int_t branch, AliITSRawCluster *c);
+    void ResetClusters();                 // one of the methods in 
+    void ResetClusters(Int_t branch);     // the pair will be kept
+    // Return pointer to the tree of clusters
+    TTree        *TreeC() {return fTreeC;}
     // Return pointers to clusters 
-    TObjArray            *Ctype() {return fCtype;}
-    Int_t                *Nctype() {return fNctype;}
-    virtual TClonesArray *ClustersAddress(Int_t id) 
+    TObjArray    *Ctype() {return fCtype;}
+    Int_t        *Nctype() {return fNctype;}
+    TClonesArray *ClustersAddress(Int_t id) 
                    {return ((TClonesArray *) (*fCtype)[id]);}
 
+    //=================== Reconstruction ===============================
+    void MakeBranchR(const char *file);
+    void SetTreeAddressR(TTree *treeR);
+    void AddRecPoint(const AliITSRecPoint &p);
+    void HitsToFastRecPoints(Int_t evNumber,Int_t bgrev,Int_t size,
+                 Option_t *add, Option_t *det, Text_t *filename);
+    void Digits2Reco();
+    void DigitsToRecPoints(Int_t evNumber,Int_t lastEntry,Option_t *det);
+    void ResetRecPoints();
     // Return pointer to rec points 
     TClonesArray  *RecPoints()   {return fRecPoints;}
 
-    // Return pointer to DetType #id
-    AliITSDetType  *DetType(Int_t id);
-    //Int_t           NDetTypes() {return fNDetTypes;}
+ protected:
+    //================== Data Members ==================================
+    AliITSgeom   *fITSgeom;    // Pointer to ITS geometry
+    Bool_t       fEuclidOut;   // Flag to write geometry in euclid format
+    TObjArray    *fITSmodules; //! Pointer to ITS modules
 
-    // Return pointer to the tree of clusters
-    TTree          *TreeC() {return fTreeC;}
+    Int_t        fIdN;         // the number of layers
+    Int_t        *fIdSens;     //[fIdN] layer identifier
+    TString      *fIdName;     //[fIdN] layer identifier
 
+    Int_t        fNDetTypes;   // Number of detector types
+    TObjArray    *fDetTypes;   // List of detector types
 
+//    TObjArray    *fSDigits;    // List of Summable digits.
+    TClonesArray  *fSDigits;   // List of Summable digits.
+    Int_t         fNSDigits;   // Number of Summable Digits.
 
- protected:
+    TObjArray    *fDtype;      // List of digits
+    Int_t        *fNdtype;     //[fNDetTypes] Num. of digits per type of det. 
 
-    AliITSgeom *fITSgeom;      // Pointer to ITS geometry
-    TObjArray  *fITSmodules;   //! Pointer to ITS modules
-    Bool_t      fEuclidOut;    // Flag to write geometry in euclid format
-    Int_t       fIdN;          // the number of layers
-    Int_t      *fIdSens;       //[fIdN] layer identifier
-    TString    *fIdName;       //[fIdN] layer identifier
-    //
-    Int_t          fNDetTypes;   // Number of detector types
-    TObjArray     *fDetTypes;    // List of detector types
-
-    TObjArray     *fDtype;       // List of digits
-    Int_t         *fNdtype;      //[fNDetTypes] Num. of digits per type of det. 
-    TObjArray     *fCtype;       // List of clusters
-    Int_t         *fNctype;      //[fNDetTypes] Num. of clust. per type of det.
-
-    TClonesArray  *fRecPoints;   // List of reconstructed points
-    Int_t          fNRecPoints;  // Number of rec points
-    TTree         *fTreeC;       // Tree for raw clusters
+    TObjArray    *fCtype;      // List of clusters
+    Int_t        *fNctype;     //[fNDetTypes] Num. of clust. per type of det.
+    TTree        *fTreeC;      // Tree for raw clusters
 
+    TClonesArray *fRecPoints;  // List of reconstructed points
+    Int_t         fNRecPoints; // Number of rec points
 
     ClassDef(AliITS,1) // Base class for ITS
 };
index 8dd19cd..2e1fdd4 100644 (file)
@@ -1,6 +1,6 @@
 /**************************************************************************
  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
- *                                                                         *
+ *                                                                        *
  * Author: The ALICE Off-line Project.                                    *
  * Contributors are mentioned in the code where appropriate.              *
  *                                                                        *
@@ -14,6 +14,7 @@
  **************************************************************************/
 
 #include <TString.h>
+#include <TRandom.h>
 
 #include "AliITSresponseSDD.h"
 
@@ -24,6 +25,10 @@ ClassImp(AliITSresponseSDD)
 AliITSresponseSDD::AliITSresponseSDD()
 {
   // constructor
+  //   fModules = 520;
+  //   fChips = 4;
+  //   fChannels = 64;
+   SetDeadChannels();
    SetMaxAdc();
    SetDiffCoeff();
    SetDriftSpeed();
@@ -45,8 +50,8 @@ AliITSresponseSDD::AliITSresponseSDD()
    // set the default zero suppression parameters
    fCPar[0]=0;
    fCPar[1]=0;
-   fCPar[2]=(Int_t)(fBaseline + 2.*fNoiseAfterEl);
-   fCPar[3]=(Int_t)(fBaseline + 2.*fNoiseAfterEl);
+   fCPar[2]=(Int_t)(fBaseline + 2.*fNoiseAfterEl + 0.2);
+   fCPar[3]=(Int_t)(fBaseline + 2.*fNoiseAfterEl + 0.2);
    fCPar[4]=0;
    fCPar[5]=0;
    fCPar[6]=0;
@@ -80,6 +85,95 @@ void AliITSresponseSDD::GiveCompressParam(Int_t  cp[8])
     }
 }
 
+void AliITSresponseSDD::SetDeadChannels(Int_t nmod, Int_t nchip, Int_t nchan) {
+
+  for(Int_t m=0; m<fModules; m++) 
+    for(Int_t n=0; n<fChips; n++) 
+      for(Int_t p=0; p<fChannels; p++) 
+       fGain[m][n][p] = 1.;
+
+  if(nmod < 0 || nmod > fModules) { cout << "Wrong number of dead modules: " << nmod << endl; return; }
+  Int_t nmax = (fModules-nmod)*fChips; 
+  if(nchip < 0 || nchip > nmax) { cout << "Wrong number of dead chips: " << nchip << endl; return; }
+  nmax = ((fModules - nmod)*fChips - nchip)*fChannels; 
+  if(nchan < 0 || nchan > nmax) { cout << "Wrong number of dead channels: " << nchan << endl; return; }
+  
+  TRandom *gran = new TRandom();
+  
+//  cout << "modules" << endl;
+  Int_t mod[nmod];
+  for(Int_t i=0;i<nmod;i++) {
+    mod[i] = (Int_t) (1.+fModules*gran->Uniform());
+    cout << i+1 << ": Dead module nr: " << mod[i] << endl;
+    for(Int_t n=0; n<fChips; n++)
+      for(Int_t p=0; p<fChannels; p++)
+       fGain[mod[i]-1][n][p] = 0.;
+  }
+
+//  cout << "chips" << endl;
+  Int_t chip[nchip];
+  Int_t chip_mod[nchip];
+  Int_t i=0;
+  while(i<nchip) {
+    Int_t module = (Int_t) (fModules*gran->Uniform() + 1.);
+    if(module <=0 || module > fModules) cout << "Wrong module: " << module << endl;
+    Int_t flag_mod = 0;
+    for(Int_t k=0;k<nmod;k++) if(module == mod[k]) flag_mod = 1;
+    if(flag_mod == 1) continue;
+    Int_t chi = (Int_t) (fChips*gran->Uniform() + 1.);
+    if(chi <=0 || chi > fChips) cout << "Wrong chip: " << chi << endl;
+    i++;
+    chip[i-1] = chi; 
+    chip_mod[i-1] = module;
+    for(Int_t m=0; m<fChannels; m++) fGain[module-1][chi-1][m] = 0.;
+    cout << i << ": Dead chip nr. " << chip[i-1] << " in module nr: " << chip_mod[i-1] << endl;
+  }
+
+//  cout << "channels" << endl;
+  Int_t channel[nchan];
+  Int_t channel_chip[nchan];
+  Int_t channel_mod[nchan];
+  i=0;
+  while(i<nchan) {
+    Int_t module = (Int_t) (fModules*gran->Uniform() + 1.);
+    if(module <=0 || module > fModules) cout << "Wrong module: " << module << endl;
+    Int_t flag_mod = 0;
+    for(Int_t k=0;k<nmod;k++) if(module == mod[k]) flag_mod = 1;
+    if(flag_mod == 1) continue;
+    Int_t chipp = (Int_t) (fChips*gran->Uniform() + 1.);
+    if(chipp <=0 || chipp > fChips) cout << "Wrong chip: " << chipp << endl;
+    Int_t flag_chip = 0;
+    for(Int_t k=0;k<nchip;k++) if(chipp == chip[k] && module == chip_mod[k]) flag_chip = 1;
+    if(flag_chip == 1) continue;
+    i++;
+    channel[i-1] = (Int_t) (fChannels*gran->Uniform() + 1.); 
+    if(channel[i-1] <=0 || channel[i-1] > fChannels) cout << "Wrong channel: " << channel[i-1] << endl;
+    channel_chip[i-1] = chipp;
+    channel_mod[i-1] = module;
+    fGain[module-1][chipp-1][channel[i-1]-1] = 0.;
+    cout << i << ": Dead channel nr. " << channel[i-1] << " in chip nr. " << channel_chip[i-1] << " in module nr: " << channel_mod[i-1] << endl;
+  }
+
+  /*  
+  delete [] mod;
+  delete [] chip;
+  delete [] chip_mod;
+  delete [] channel;
+  delete [] channel_mod;
+  delete [] channel_chip;
+  */
+}
+
+void AliITSresponseSDD::PrintGains()
+{
+  // Print SDD electronic gains
+  for(Int_t t=0; t<fModules;t++)
+    for(Int_t u=0; u<fChips;u++)
+      for(Int_t v=0; v<fChannels;v++)
+       cout << "Gain for Module: " << t+1 << ", Chip " << u+1 << ", Channel " << v+1 << " = " << fGain[t][u][v] << endl;
+
+}
+
 void AliITSresponseSDD::Print()
 {
   // Print SDD response Parameters
@@ -107,9 +201,10 @@ void AliITSresponseSDD::Print()
    cout << "Max. ADC Value: " << fMaxAdc << endl;
    cout << "Min. Value: " << fMinVal << endl;
 
+   cout << "**************************************************" << endl; 
+   cout << "             Print Electronics Gains              " << endl;
    cout << "**************************************************" << endl;
-  
-
+   PrintGains();
 
 }
 
index ef41dc2..90d9924 100644 (file)
@@ -19,7 +19,7 @@ public:
   virtual ~AliITSresponseSDD();
 
   void SetElectronics(Int_t p1=1) {
-    // Electronics: Pascal or OLA
+    // Electronics: Pascal (1) or OLA (2)
     fElectronics=p1;
   }
   
@@ -37,8 +37,8 @@ public:
     return fMaxAdc;
   }                       
   
-  void    SetChargeLoss(Float_t p1=0.01) {
-    // Set Linear Charge Loss Steepness  
+  void    SetChargeLoss(Float_t p1=0.0) {
+    // Set Linear Charge Loss Steepness  // 0.01 for 20%
     fChargeLoss=p1;
   }
   Float_t ChargeLoss()  {
@@ -102,12 +102,12 @@ public:
     strcpy(opt1,fParam1.Data()); strcpy(opt2,fParam2.Data());
   }
   
-  void  SetNoiseParam(Float_t n=8.3, Float_t b=20.){
-    // Noise and baseline
+  void  SetNoiseParam(Float_t n=0., Float_t b=20.){
+    // Noise and baseline  // 8.3 for ALICE with beam test measurements
     fNoise=n; fBaseline=b;
   }   
-  void  SetNoiseAfterElectronics(Float_t n=1.6){
-    // Noise after electronics (ADC units)
+  void  SetNoiseAfterElectronics(Float_t n=0.){
+    // Noise after electronics (ADC units) // 1.6 for ALICE from beam test measurements
     fNoiseAfterEl=n;
   }   
   void  GetNoiseParam(Float_t &n, Float_t &b) {
@@ -205,6 +205,8 @@ public:
     if(i<0 || i>=fNcomps) return 0.;
     return fGaus->At(i);
   }
+  void SetDeadChannels(Int_t nmodules=0, Int_t nchips=0, Int_t nchannels=0);
+  void    PrintGains();
   void    Print();
 
 
@@ -215,6 +217,11 @@ private:
     
 protected:
   
+  static const Int_t fModules = 520;     // Total number of SDD modules
+  static const Int_t fChips = 4;        // Number of chips/module
+  static const Int_t fChannels = 64;    // Number of channels/chip
+  Float_t   fGain[fModules][fChips][fChannels];   // Array for channel gains
+
   Int_t     fCPar[8];        // Hardware compression parameters
   Float_t   fNoise;          // Noise
   Float_t   fBaseline;       // Baseline
index 18f3d44..483b984 100644 (file)
 #include <TMath.h>
 
 #include "AliITSresponseSPD.h"
-//___________________________________________
-ClassImp(AliITSresponseSPD)    
 
-AliITSresponseSPD::AliITSresponseSPD()
-{
+ClassImp(AliITSresponseSPD)    
+//______________________________________________________________________
+AliITSresponseSPD::AliITSresponseSPD(){
   // constructor
+
    SetThresholds();
    SetNoiseParam();
    SetDataType();
+   SetFractionDead();
 }
 
index dd01821..ac67827 100644 (file)
@@ -1,5 +1,11 @@
 #ifndef ALIITSRESPONSESPD_H
 #define ALIITSRESPONSESPD_H
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                               */
+
+/*
+$Id$
+*/
 
 #include "AliITSresponse.h"
 #include <TString.h>
 //
 // ITS response class for SPD
 //
-class AliITSresponseSPD :
-  public AliITSresponse {
-public:
-  
-  AliITSresponseSPD();
-  virtual ~AliITSresponseSPD() { 
-    // destructror
-  }
-  //
-  // Configuration methods
-  //
-  
-  
-  virtual  void   SetDiffCoeff(Float_t p1=0) {
-    // 
-    fDiffCoeff=p1;
-  }
-  virtual  Float_t   DiffCoeff() {
-    // 
-    return fDiffCoeff;
-  }
-  virtual  void   SetThresholds(Float_t thresh=2000, Float_t sigma=280) {
+class AliITSresponseSPD :  public AliITSresponse {
+ public:
+    AliITSresponseSPD(); // default constructor
+    virtual ~AliITSresponseSPD() {} // destructror
+    // Configuration methods
+    // sets the diffusion coeffeciant.
+    virtual  void   SetDiffCoeff(Float_t p1=0) {fDiffCoeff=p1;}
+    // returns the diffusion coeffeciant
+    virtual  Float_t   DiffCoeff() {return fDiffCoeff;}
     // Set Threshold and noise + threshold fluctuations parameter values
-    fThresh=thresh; fSigma=sigma;
-  }
-  virtual  void   Thresholds(Float_t &thresh, Float_t &sigma) {
+    virtual  void   SetThresholds(Float_t thresh=2000, Float_t sigma=280)
+       {fThresh=thresh; fSigma=sigma;}
     // Get Threshold and noise + threshold fluctuations parameter values
-    thresh=fThresh; sigma=fSigma;
-  }
-  virtual  void   SetNoiseParam(Float_t col=0., Float_t row=0.) {
+    virtual  void   Thresholds(Float_t &thresh, Float_t &sigma)
+       {thresh=fThresh; sigma=fSigma;}
     // set coupling parameters
-    fCouplCol=col; fCouplRow=row;
-  }   
-  virtual  void   GetNoiseParam(Float_t &col, Float_t &row) {
+    virtual  void   SetNoiseParam(Float_t col=0., Float_t row=0.)
+       {fCouplCol=col; fCouplRow=row;}   
     // get coupling parameters
-    col=fCouplCol; row=fCouplRow;
-  }       
-  virtual void    SetDataType(char *data="simulated") {
+    virtual  void   GetNoiseParam(Float_t &col, Float_t &row)
+       {col=fCouplCol; row=fCouplRow;}
+    // Sets the fraction of Dead SPD Pixels
+    virtual void SetFractionDead(Float_t d=0.01){ fDeadPixels = d;}
+    // Retruns the fraction of Dead SPD Pixels
+    virtual Float_t GetFractionDead(){return fDeadPixels;}
     // Type of data - real or simulated
-    fDataType=data;
-  }
-  virtual const char  *DataType() {
+    virtual void    SetDataType(char *data="simulated") {fDataType=data;}
     // Get data typer
-    return fDataType.Data();
-  } 
-  
-  ClassDef(AliITSresponseSPD,1) // SPD response
-    
-    protected:
-  
-  Float_t fDiffCoeff;       // Sigma diffusion coefficient (not used) 
-  Float_t fThresh;          // Threshold value
-  Float_t fSigma;           // Noise + threshold fluctuations value
-  Float_t fCouplCol;        // Coupling probability along a column
-  Float_t fCouplRow;        // Coupling probability along a row
+    virtual const char  *DataType() {return fDataType.Data();}
+
+ protected:
+    Float_t fDiffCoeff;       // Sigma diffusion coefficient (not used) 
+    Float_t fThresh;          // Threshold value
+    Float_t fSigma;           // Noise + threshold fluctuations value
+    Float_t fCouplCol;        // Coupling probability along a column
+    Float_t fCouplRow;        // Coupling probability along a row
+    Float_t fDeadPixels;      // the fraction of dead pixels
+
+    TString fDataType;        // Type of data - real or simulated
 
-  TString fDataType;        // Type of data - real or simulated
+    ClassDef(AliITSresponseSPD,1) // SPD response
 };
 
 #endif
index 350d434..92e084a 100644 (file)
@@ -77,15 +77,19 @@ class AliITSresponseSSD : public AliITSresponse {
        // Get sigmas for the charge spread 
        sP=fSigmaP; sN=fSigmaN;
     }
-    virtual void SetADCpereV(Float_t a=50./30000.0){ // Sets eV to ADC value
+    virtual void SetADCpereV(Float_t a=50./30000.0){ // Sets electron-hole
+       // pairs to ADC value conversion factor are rather arbitrary
+       // (need tuning) minimum ionizing particle--> ~30000 pairs--> ADC
+       // channel 50
        fADCpereV = a;
     }
-    virtual Double_t DEvToADC(Double_t eV){ // Converts eV to ADC value
-       // conversion factor are rather arbitrary (need tuning)
+    virtual Double_t DEvToADC(Double_t eV){ // Converts electron-hole pairs to
+       // ADC value conversion factor are rather arbitrary (need tuning)
        // minimum ionizing particle--> ~30000 pairs--> ADC channel 50
        return eV*fADCpereV;
     }
-    virtual Int_t IEvToADC(Double_t eV){ // Converts eV to ADC value
+    virtual Int_t IEvToADC(Double_t eV){ // Converts electron-hole pairs to
+       // ADC value
        return ((Int_t) DEvToADC(eV));
     }