Bug fix, thanks to Ludovic.

diff --git a/ITS/AliITS.cxx b/ITS/AliITS.cxx
index 7bc4db393bb661cb6cb78316ec3bca8a543213c7..40eefb76787d58c478c1f158374cf9ad343861f5 100644 (file)
--- a/ITS/AliITS.cxx
+++ b/ITS/AliITS.cxx
@@ -645,8 +645,7 @@ void AliITS::InitModules(Int_t size,Int_t &nmodules){
             return;
         } // end if fITSgeom==0
         nl = fITSgeom->GetNlayers();
-        indexMAX = fITSgeom->GetModuleIndex(nl,fITSgeom->GetNladders(nl),
-                                            fITSgeom->GetNdetectors(nl))+1;
+        indexMAX = fITSgeom->GetIndexMax();
         nmodules = indexMAX;
         fITSmodules = new TObjArray(indexMAX);
         for(index=0;index<indexMAX;index++){

diff --git a/ITS/AliITS.h b/ITS/AliITS.h
index 6e58b7b28b0ac9b7463fccf438da2b1e92175081..9bcbee773c1ebfe71ebc2946ed0051230e80a6a3 100644 (file)
--- a/ITS/AliITS.h
+++ b/ITS/AliITS.h
@@ -9,18 +9,25 @@
 //           Manager class for set: ITS                               //
 ////////////////////////////////////////////////////////////////////////
 
+//#define NEWVERSION
+
 #include <TObjArray.h> // used in inline function GetModule.
 #include <TBranch.h>   // used in inline function SetHitsAddressBranch
 
 #include "AliRunLoader.h"
 #include "AliDetector.h"
+#ifndef NEWVERSION
 #include "AliITSDetType.h"
+#endif
+#ifdef NEWVERSION
+#include "AliITSDetTypeSim.h"
+#include "AliITSDetTypeRec.h"
+#endif
 
 class TString;
 class TTree;
 class TFile;
 
-//class AliITSDetType;
 class AliITSsimulation;
 class AliITSClusterFinder;
 class AliITSLoader;
@@ -60,6 +67,7 @@ class AliITS : public AliDetector {
     virtual void  SetEUCLID(Bool_t euclid=kTRUE) {fEuclidOut = euclid;}
     virtual Bool_t GetEUCLID()const {return fEuclidOut;}
     //-------------------- Geometry Transformations --------------------
+#ifndef NEWVERSION
     // ITS geometry functions
     AliITSgeom   *GetITSgeom() const {return fITSgeom;}
     // Sets ITS geometry ! be very careful using this function.
@@ -69,6 +77,33 @@ class AliITS : public AliDetector {
     // return pointer to a particular module
     AliITSmodule *GetModule(Int_t index) {return (AliITSmodule *)
                                              (fITSmodules->At(index));}
+#endif
+#ifdef NEWVERSION
+    // ITS geometry functions
+    AliITSgeom* GetITSgeom()const{if(fDetTypeSim!=0)
+        return fDetTypeSim->GetITSgeom();else if(fDetTypeRec!=0) 
+            return fDetTypeRec->GetITSgeom();else return 0;}
+    // ITS geometry functions From Simulation
+    AliITSgeom* GetITSgeomSim()const{if(fDetTypeSim!=0)
+        return fDetTypeSim->GetITSgeom();else return 0;}
+    // ITS geometry functions From Reconstruction
+    AliITSgeom* GetITSgeomRec()const{if(fDetTypeRec!=0)
+        return fDetTypeRec->GetITSgeom();else return 0;}
+    // Sets ITS geometry ! be very careful using this function.
+    void   SetITSgeom(AliITSgeom *geom) {if(fDetTypeSim!=0)
+        fDetTypeSim->SetITSgeom(geom);if(fDetTypeRec!=0) 
+            fDetTypeRec->SetITSgeom(geom);}
+    // Sets ITS geometry For Simulation ! be very careful using this function.
+    void   SetITSgeomSim(AliITSgeom *geom) {if(fDetTypeSim!=0)
+        fDetTypeSim->SetITSgeom(geom);}
+    // Sets ITS geometry For Reconstruction! be very careful using this fun.
+    void   SetITSgeomRec(AliITSgeom *geom) {if(fDetTypeRec!=0)
+        fDetTypeRec->SetITSgeom(geom);}
+    // return pointer to the array of modules
+    TObjArray    *GetModules() const {return fDetTypeSim->GetModules();}
+    // return pointer to a particular module
+    AliITSmodule *GetModule(Int_t index){return fDetTypeSim->GetModule(index);}
+#endif
 
     //================ Necessary general Classes =======================
     virtual void Init();
@@ -78,18 +113,21 @@ class AliITS : public AliDetector {
     virtual void SetDefaultClusterFinders();
     virtual void MakeBranch(Option_t *opt=" ");
     virtual void SetTreeAddress();
+#ifndef NEWVERSION
     // For a given branch from the treeH sets the TClonesArray address.
     virtual void SetHitsAddressBranch(TBranch *b) {b->SetAddress(&fHits);}
     // Return pointer to DetType #id
     AliITSDetType *DetType(Int_t id){
         return ((AliITSDetType*) fDetTypes->At(id));};
     //Int_t           NDetTypes() {return fNDetTypes;}
+#endif
     //---------- Configuration Methods (per detector type) -------------
     // Determines which ITS subdetectors will be processed. Effects
     // digitization, and Reconstruction only.
     void SetDetectors(Option_t *opt="All"){fOpt = opt;}
     // Returns the list of ITS subdetectors that will be processed.
     Option_t* GetDetectors(){return fOpt;}
+#ifndef NEWVERSION
     // Set response 
     virtual void SetResponseModel(Int_t id, AliITSresponse *response){
         ((AliITSDetType*) fDetTypes->At(id))->ResponseModel(response);};
@@ -108,18 +146,80 @@ class AliITS : public AliDetector {
     // Set class names for digit and rec point 
     virtual void SetClasses(Int_t id, const char *digit, const char *cluster){
         ((AliITSDetType*) fDetTypes->At(id))->ClassNames(digit,cluster);};
+#endif
+#ifdef NEWVERSION
+    // Set response
+    virtual void SetResponseModel(Int_t module, AliITSresponse *response){
+        fDetTypeSim->SetResponseModel(module,response);};
+    // Set segmentation for Simulation
+    virtual void SetSegmentationModelSim(Int_t id, AliITSsegmentation *seg){
+        fDetTypeSim->SetSegmentationModel(id,seg);};
+    // Set segmentation for Reconstruction
+    virtual void SetSegmentationModelRec(Int_t id, AliITSsegmentation *seg){
+        fDetTypeRec->SetSegmentationModel(id,seg);};
+    // Set segmentation 
+    virtual void SetSegmentationModel(Int_t id, AliITSsegmentation *seg){
+        SetSegmentationModelSim(id,seg);SetSegmentationModelRec(id,seg);};
+    // Set simulation 
+    virtual void SetSimulationModel(Int_t id, AliITSsimulation *sim){
+        fDetTypesSim->SetSimulationModel(sim);};
+    // Set simulation 
+    virtual AliITSsimulation* GetSimulationModel(Int_t id){
+       return fDetTypesSim->GetSimulationModel(id);}
+    // Set Calibration
+    virtual void SetCalibrationModel(Int_t module, AliITSCalibration *cal){
+        fDetTypeRec->SetCalibrationModel(module,cal);};
+    // Set reconstruction 
+    virtual void SetReconstructionModel(Int_t id, AliITSClusterFinder *rec){
+        fDetTypesRec->SetReconstructionModel(id,rec);};
+    // Set Class name for Hits
+    virtual void SetHitClassName(){
+        fDetTypeSim->SetHitClassName(this->GetName());}
+    // Set Class name for SDigits
+    virtual void SetSDigitClassName(const char *sdigit){
+        fDetTypeSim->SetSDigitClassName(sdigit);}
+    // Set Class name for Digits for simulation
+    virtual void SetDigitClassNameSim(const char *digit){
+        fDetTypeSim->SetDigitClassName(digit);}///////// Array of names
+    // Set Class name for Digits for Reconstruction
+    virtual void SetDigitClassNameRec(const char *digit){
+        fDetTypeRec->SetDigitClassName(digit);}///////// Array of names
+    virtual void SetClusterClassName(const char *digit){
+        fDetTypeRec->SetClusterClassName(digit);}///////// Array of names
+    virtual void SetRecPointClassName(const char *digit){
+        fDetTypeRec->SetRecPointClassName(digit);}///////// Array of names
+    // Set class names for digit and rec point 
+    virtual void SetClasses(Int_t id, const char *digit, const char *cluster){
+        SetDigitClassNameSim(digit);SetDigitClassNameRec(digit);
+        SetRecPointClassName(cluster);};
+#endif
 
     //=================== 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(TTree *treeH, Int_t mask = 0);
     virtual void FillModules(Int_t evnt,Int_t bgrev,Int_t nmodules,
                             Option_t *opt, const char *filename);
+#ifndef NEWVERSION
+    virtual void AddHit(Int_t track, Int_t *vol, Float_t *hits);
+    virtual void InitModules(Int_t size,Int_t &nmodules);  
+    virtual void FillModules(TTree *treeH, Int_t mask = 0);
     virtual void ClearModules(){if(fITSmodules) fITSmodules->Delete();};
+#endif
+#ifdef NEWVERSION
+    virtual void AddHit(Int_t track, Int_t *vol, Float_t *hits){
+        if(fDetTypeSim!=0)fDetTypeSim->AddHit(track,vol,hits);};
+    virtual void AddHit(AliITShit &hit){
+        if(fDetTypeSim!=0)fDetTypeSim->AddHit(hit);};
+    virtual void InitModules(Int_t size,Int_t &nmodules){if(fDetTypeSim!=0)
+        fDetTypeSim->InitModules(size,nmodules);};
+    virtual void FillModules(TTree *treeH, Int_t mask = 0){if(fDetTypeSim!=0)
+        fDetTypeSim->FillModules(treeH,mask);};
+    virtual void ClearModules(){if(fDetTypeSim!=0) 
+        fDetTypeSim->ClearModules();};
+#endif
 
     //===================== Digitisation ===============================
+#ifndef NEWVERSION
     void MakeBranchS(const char *file);
     void SetTreeAddressS(TTree *treeS);
     TClonesArray * GetSDigits() { return fSDigits; }
@@ -127,6 +227,8 @@ class AliITS : public AliDetector {
     void MakeBranchD(const char *file){
        MakeBranchInTreeD(GetLoader()->TreeD(),file);}
     void SetTreeAddressD(TTree *treeD);
+#endif
+#ifndef NEWVERSION
     void Hits2SDigits(); // Turn hits into SDigits
     void Hits2PreDigits(){ // Turn hits into SDigits
         HitsToPreDigits(fLoader->GetRunLoader()->GetEventNumber(),
@@ -146,7 +248,18 @@ class AliITS : public AliDetector {
     // Standard Hits To Digits function
     void HitsToDigits(Int_t evNumber,Int_t bgrev,Int_t size,
                  Option_t *add, Option_t *det, const char *filename);
+#endif
+#ifdef NEWVERSION
+    // Turn hits into SDigits
+    void Hits2SDigits(){if(fDetTypeSim)fDetTypeSim->Hits2SDigits();};
+    AliDigitizer* CreateDigitizer(AliRunDigitizer* manager) const;
+    // Turn SDigits to Digits
+    void SDigits2Digits(){if(fDetTypeSim)fDetTypeSim->SDigits2Digits();} 
+    // Turn hits straight into Digits.
+    void Hits2Digits(){if(fDetTypeSim)fDetTypeSim->Hits2Digits();};
+#endif
     // Resets the Summable digits.
+#ifndef NEWVERSION
     void ResetSDigits(){if(fSDigits) fSDigits->Clear();fNSDigits = 0;};
     void ResetDigits();                   // depending on how the
     void ResetDigits(Int_t branch);       // tree will be filled only
@@ -155,12 +268,37 @@ class AliITS : public AliDetector {
     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);
+#endif
     // Return pointers to digits 
+#ifndef NEWVERSION
     TObjArray    *Dtype() {return fDtype;}
     Int_t        *Ndtype() {return fNdtype;}
     TClonesArray *DigitsAddress(Int_t id)
        {return ((TClonesArray *) (*fDtype)[id]);}
+#endif
+#ifdef NEWVERSION
+    TObjArray* GetDigitsSim(){if(fDetTypeSim!=0) 
+        return fDetTypeSim->GetDigits();else return 0;}
+    TObjArray* GetDigitsRec(){if(fDetTypeRec!=0) 
+        return fDetTypeRec->GetDigits();else return 0;}
+    TObjArray    *Dtype() {if(fDetTypeSim!=0) return GetDigitsSim();
+    else if(fDetTypeRec!=0) return GetDigitsRec(); else return 0;}
+    Int_t* GetNDigitArraySim(){if(fDetTypeSim!=0) 
+        fDetTypeSim->GetNDigitArray();}
+    Int_t* GetNDigitArrayRec(){if(fDetTypeRec!=0) 
+        fDetTypeRec->GetNDigitArray();}
+    Int_t        *Ndtype() {if(fDetTypeSim!=0) return GetNDigitArraySim();
+        else if(fDetTypeRec!=0) return GetNDigitArrayRec(); else return 0;}
+    TClonesArray *DigitsAddressSim(Int_t id){if(fDetTypeSim!=0)
+       return fDetTypeSim->GetDigitsAddress(id);else return 0;}
+    TClonesArray *DigitsAddressRec(Int_t id){if(fDetTypeRec!=0)
+       return fDetTypeRec->GetDigitsAddress(id);else return 0;}
+    TClonesArray *DigitsAddress(Int_t id){if(fDetTypeSim!=0)
+       return DigitsAddressSim(id);else if(fDetTypeRec!=0) DigitsAddressRec(id);
+     else return 0;}
+#endif
     void SelectVertexer(TString sel=" "){fSelectedVertexer = sel;}
+#ifndef NEWVERSION
 
     //===================== Raw Data IO ================================
     // Write digits into raw data format
@@ -174,37 +312,82 @@ class AliITS : public AliDetector {
     // one of the methods in
     void ResetClusters(){for(Int_t i=0;i<kNTYPES;i++ ) ResetClusters(i);}; 
     void ResetClusters(Int_t branch);     // the pair will be kept
+    void MakeBranchC();
     // Return pointers to clusters 
     TObjArray    *Ctype() {return fCtype;}
     Int_t        *Nctype() {return fNctype;}
     TClonesArray *ClustersAddress(Int_t id) 
                    {return ((TClonesArray *) (*fCtype)[id]);}
+#endif
+#ifdef NEWVERSION
+
+    //===================== Raw Data IO ================================
+    // Write digits into raw data format
+    virtual void Digits2Raw(){if(fDetTypeSim)fDetTypeSim->Digits2Raw();};
+
+    //==================== Clusterization ==============================
+    // create separate tree for clusters - declustering refining
+    void MakeTreeC(Option_t *option="C"){fDetTypeRec->MakeTreeC();};
+    void GetTreeC(Int_t event){fDetTypeRec->GetTreeC(event);};
+    void AddCluster(Int_t branch, AliITSRawCluster *c){
+        fDetTypeRec->AddCluster(branch,c);};
+    // one of the methods in
+    void ResetClusters(){for(Int_t i=0;i<kNTYPES;i++ ) ResetClusters(i);}; 
+    void ResetClusters(Int_t branch){fDetTypeRec->ResetCluster(i);};
+    void MakeBranchC(){fDetTypeRec->MakeBranchC();};
+    // Return pointers to clusters 
+    TObjArray    *Ctype() {if(fDetTypeRec!=0)
+        return fDetTypeRec->GetClusterArray(); else return 0;}
+    Int_t        *Nctype() {if(fDetTypeRec!=0) 
+        return fDetTypeRec->GetNClusters(); else return 0;;}
+    TClonesArray *ClustersAddress(Int_t id){if(fDetTypeRec!=0) 
+        return fDetTypeRec->GetClusterAddress(id]); else return 0;}
+#endif
 
     //=================== Reconstruction ===============================
+#ifndef NEWVERSION
     void MakeBranchR(const char *file, Option_t *opt=" ");
-    void MakeBranchRF(const char *file){MakeBranchR(file,"Fast");}
-    void MakeBranchC();
     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, const char *filename);
-    void Digits2Reco(){DigitsToRecPoints(fLoader->GetRunLoader()->GetEventNumber(),0,fOpt);};
-    void DigitsToRecPoints(Int_t evNumber,Int_t lastEntry,Option_t *det);
     void ResetRecPoints(){if(fRecPoints) fRecPoints->Clear();fNRecPoints = 0;};
     // Return pointer to rec points 
     TClonesArray  *RecPoints()   {return fRecPoints;}
+#endif
+#ifdef NEWVERSION
+    void MakeBranchR(const char *file, Option_t *opt=" ");
+    void SetTreeAddressR(TTree *treeR){fDetTypeRec->SetTreeAddressR(treeR);};
+    void AddRecPoint(const AliITSRecPoint &p){fDetTypeRec->AddRecPoint(p);};
+    void ResetRecPoints(){if(fDetTypeRec) fDetTypeRec->ResetRecPoints();};
+    // Return pointer to rec points 
+    TClonesArray* RecPoints() {if(fDetTypeRec!=0)
+        return fDetTypeRec->GetRecPoints();else return 0;}
+#endif
+    void MakeBranchRF(const char *file){MakeBranchR(file,"Fast");}
+    void HitsToFastRecPoints(Int_t evNumber,Int_t bgrev,Int_t size,
+                 Option_t *add, Option_t *det, const char *filename);
+    void Digits2Reco(){
+        DigitsToRecPoints(fLoader->GetRunLoader()->GetEventNumber(),0,fOpt);};
+    void DigitsToRecPoints(Int_t evNumber,Int_t lastEntry,Option_t *det);
 
  protected:
     //================== Data Members ==================================
+#ifdef NEWVERSION
+    AliITSDetTypeSim *fDetTypeSim; //
+    AliITSDetTypeRec *fDetTypeRec; //
+#endif
+#ifndef NEWVERSION
     AliITSgeom   *fITSgeom;    // Pointer to ITS geometry
+#endif
     Bool_t        fEuclidOut;  // Flag to write geometry in euclid format
+#ifndef NEWVERSION
     TObjArray    *fITSmodules; //! Pointer to ITS modules
+#endif
     Option_t     *fOpt;        //! Detector option ="All" unless changed.
 
     Int_t         fIdN;        // the number of layers
     Int_t        *fIdSens;     //[fIdN] layer identifier
     TString      *fIdName;     //[fIdN] layer identifier
-
+#ifndef NEWVERSION
     Int_t         fNDetTypes;  // Number of detector types
     TObjArray    *fDetTypes;   // List of detector types
 
@@ -219,9 +402,14 @@ class AliITS : public AliDetector {
 
     TClonesArray *fRecPoints;  //! List of reconstructed points
     Int_t         fNRecPoints; // Number of rec points
+#endif
     TString fSelectedVertexer; // Vertexer selected in CreateVertexer
-
+#ifndef NEWVERSION
     ClassDef(AliITS,4) // Base class for ITS
+#endif
+#ifdef NEWVERSION
+    ClassDef(AliITS,5) // Base class for ITS
+#endif
 };
 
 #endif

diff --git a/ITS/AliITSgeom.cxx b/ITS/AliITSgeom.cxx
index 516b3d7fb470a2d959bbf302e726c55b631edbf1..89e1bf64689095d469745a7e6c56dbe569d845f3 100644 (file)
--- a/ITS/AliITSgeom.cxx
+++ b/ITS/AliITSgeom.cxx
@@ -608,6 +608,7 @@ Int_t AliITSgeom::GetModuleIndex(Int_t lay,Int_t lad,Int_t det){
     j = 0;
     for(k=0;k<lay-1;k++) j += fNdet[k]*fNlad[k];
     i = i+j;
+    if(i>=fNmodules) return -1;
     GetGeomMatrix(i)->GetIndex(id);
     if(id[0]==lay&&id[1]==lad&&id[2]==det) return i;
     // Array of modules fGm is not in expected order. Search for this index