The segmentations are made data member of the AliITSUGeomTGeo, will be loaded
authorshahoian <shahoian@f7af4fe6-9843-0410-8265-dc069ae4e863>
Wed, 7 Nov 2012 01:49:33 +0000 (01:49 +0000)
committershahoian <shahoian@f7af4fe6-9843-0410-8265-dc069ae4e863>
Wed, 7 Nov 2012 01:49:33 +0000 (01:49 +0000)
at initialization. Code using independend segmentations loading is changed
to obtain it from AliITSUGeomTGeo

12 files changed:
EVE/EveDet/AliEveITSUModule.cxx
EVE/alice-macros/itsU_clusters.C
ITS/UPGRADE/AliITSUGeomTGeo.cxx
ITS/UPGRADE/AliITSUGeomTGeo.h
ITS/UPGRADE/AliITSURecoDet.cxx
ITS/UPGRADE/AliITSURecoDet.h
ITS/UPGRADE/AliITSURecoLayer.cxx
ITS/UPGRADE/AliITSURecoLayer.h
ITS/UPGRADE/AliITSUReconstructor.cxx
ITS/UPGRADE/AliITSUReconstructor.h
ITS/UPGRADE/readDigits.C
ITS/UPGRADE/testITSU/drawLr.C

index 1b8891b..81f7b84 100644 (file)
@@ -20,7 +20,7 @@
 //#include "UPGRADE/AliITSUDigitPix.h"
 
 #include <AliITSUGeomTGeo.h>
-#include <AliITSUSegmentationPix.h>
+#include <AliITSsegmentation.h>
 #include <AliITSUDigitPix.h>
 //______________________________________________________________________________
 //
@@ -35,7 +35,7 @@ TEveFrameBox*    AliEveITSUModule::fgITSUFrameBoxDead = 0;
 TEveRGBAPalette* AliEveITSUModule::fgITSUPalette  = 0;
 
 AliITSUGeomTGeo* fGM                 = 0;
-AliITSUSegmentationPix * fSegm       = 0;
+const AliITSsegmentation* fSegm      = 0;
 
 /******************************************************************************/
 
@@ -65,23 +65,13 @@ AliEveITSUModule::AliEveITSUModule(AliITSUGeomTGeo *gm, Int_t id, Int_t layer, I
   // 
   // constructor
   //
-
   fGM = gm; // ITSU Geometry Manager
-
   fgStaticInitDone = kFALSE; 
-
-  TObjArray segmArr;
-  AliITSUSegmentationPix::LoadSegmentations(&segmArr, AliITSUGeomTGeo::GetITSsegmentationFileName());
-  int detType = fGM->GetModuleDetTypeID(id);
-  fSegm = (AliITSUSegmentationPix*)segmArr.At(detType);
-  
-  fDpx = fSegm->Dpx();  // pixel pitch in x
-  fDpz = fSegm->Dpz(0); // pixel pitch in z
-
+  fSegm = fGM->GetSegmentation(layer);
+  fDpx = fSegm->Dpx(0);  // pixel pitch in x
+  fDpz = fSegm->Dpz(0);  // pixel pitch in z
   SetID(id);
-  
-
+  //
 }
 
 AliEveITSUModule::~AliEveITSUModule()
@@ -103,8 +93,8 @@ void AliEveITSUModule::InitStatics()
   if (fgStaticInitDone) return;
   fgStaticInitDone = kTRUE;
 
-  Float_t dx =  fSegm->Dpx() * fSegm->GetNRow(); // dimension in x in cm
-  Float_t dz =  fSegm->Dpz(0)* fSegm->GetNCol(); // dimension in y in cm
+  Float_t dx =  fSegm->Dx(); // dimension in x in cm
+  Float_t dz =  fSegm->Dz(); // dimension in y in cm
   Float_t dy =  0;// ? eventuelly a few 100 micron, right?
 
   {
index d2503a0..bc24ccb 100644 (file)
@@ -38,9 +38,7 @@ void itsU_clusters(TEveElement* cont=0, Float_t maxR=50)
   rl->LoadRecPoints("ITS");
 
   gGeoManager = gEve->GetGeometry("geometry.root");
-  AliITSUGeomTGeo* gm = new AliITSUGeomTGeo(kTRUE);
-  TObjArray segmArr;
-  AliITSUSegmentationPix::LoadSegmentations(&segmArr, AliITSUGeomTGeo::GetITSsegmentationFileName());
+  AliITSUGeomTGeo* gm = new AliITSUGeomTGeo(kTRUE,kTRUE);
 
   TTree *cTree = rl->GetTreeR("ITS", false);
   if (cTree == 0)
@@ -67,13 +65,11 @@ void itsU_clusters(TEveElement* cont=0, Float_t maxR=50)
   for (int ilr=0;ilr<nlr;ilr++) {
     TClonesArray* clr = (TClonesArray*)layerClus.At(ilr);
     int ncl = clr->GetEntries();
-
+    //      AliITSUSegmentationPix* segm = (AliITSUSegmentationPix*)fGM->GetSegmentation(ilr);
     Float_t maxRsqr = maxR*maxR;
     for (Int_t icl = 0; icl < ncl; ++icl) {
       AliCluster *c = (AliCluster*) clr->UncheckedAt(icl);
       Int_t mod = c->GetVolumeId();
-      //      int detType = gm->GetModuleDetTypeID(mod);
-      //      AliITSUSegmentationPix* segm = (AliITSUSegmentationPix*)segmArr.At(detType);
       int lay,lad,det;
       gm->GetModuleId(mod, lay,lad,det);
       
index fc86604..3123ea1 100644 (file)
 #include <TGeoPhysicalNode.h>
 #include <TDatime.h>
 #include <TMath.h>
+#include <TSystem.h>
 
 #include "AliITSUGeomTGeo.h"
 #include "AliLog.h"
 #include "AliAlignObj.h"
+#include "AliITSsegmentation.h"
+#include "AliITSUSegmentationPix.h"
 using namespace TMath;
 
 ClassImp(AliITSUGeomTGeo)
@@ -52,7 +55,7 @@ const char* AliITSUGeomTGeo::fgkITSDetTypeName[AliITSUGeomTGeo::kNDetTypes] = {"
 TString     AliITSUGeomTGeo::fgITSsegmFileName = "itsSegmentations.root";
 
 //______________________________________________________________________
-AliITSUGeomTGeo::AliITSUGeomTGeo(Bool_t build)
+AliITSUGeomTGeo::AliITSUGeomTGeo(Bool_t build, Bool_t loadSegm)
   :fVersion(kITSVNA)
   ,fNLayers(0)
   ,fNModules(0)
@@ -62,9 +65,10 @@ AliITSUGeomTGeo::AliITSUGeomTGeo(Bool_t build)
   ,fLastModIndex(0)
   ,fMatSens(0)
   ,fMatT2L(0)
+  ,fSegm(0)
 {
   // default c-tor
-  if (build) BuildITS();
+  if (build) BuildITS(loadSegm);
 }
 
 //______________________________________________________________________
@@ -79,6 +83,7 @@ AliITSUGeomTGeo::AliITSUGeomTGeo(const AliITSUGeomTGeo &src)
   ,fLastModIndex(0)
   ,fMatSens(0)
   ,fMatT2L(0)
+  ,fSegm(0)
 {
   // copy c-tor
   if (fNLayers) {
@@ -105,7 +110,17 @@ AliITSUGeomTGeo::AliITSUGeomTGeo(const AliITSUGeomTGeo &src)
       fMatT2L->SetOwner(kTRUE);
       for (int i=0;i<fNModules;i++) {
        const TGeoHMatrix* mat =(TGeoHMatrix*) src.fMatT2L->At(i);
-       fMatSens->AddAt(new TGeoHMatrix(*mat),i);
+       fMatT2L->AddAt(new TGeoHMatrix(*mat),i);
+      }
+    }
+    if (src.fSegm) {
+      int sz = src.fSegm->GetEntriesFast();
+      fSegm = new TObjArray(sz);
+      fSegm->SetOwner(kTRUE);
+      for (int i=0;i<sz;i++) {
+       AliITSsegmentation* sg = (AliITSsegmentation*)src.fSegm->UncheckedAt(i);
+       if (!sg) continue;
+       fSegm->AddAt(sg->Clone(),i);
       }
     }
   }
@@ -121,6 +136,7 @@ AliITSUGeomTGeo::~AliITSUGeomTGeo()
   delete[] fLastModIndex;
   delete fMatT2L;
   delete fMatSens;
+  delete fSegm;
 }
 
 
@@ -155,6 +171,16 @@ AliITSUGeomTGeo& AliITSUGeomTGeo::operator=(const AliITSUGeomTGeo &src)
        fMatT2L->AddAt(new TGeoHMatrix(*mat),i);
       }
     }
+    if (src.fSegm) {
+      int sz = src.fSegm->GetEntriesFast();
+      fSegm = new TObjArray(sz);
+      fSegm->SetOwner(kTRUE);
+      for (int i=0;i<sz;i++) {
+       AliITSsegmentation* sg = (AliITSsegmentation*)src.fSegm->UncheckedAt(i);
+       if (!sg) continue;
+       fSegm->AddAt(sg->Clone(),i);
+      }
+    }
     //
     if (fNLayers) {
       fNLadders   = new Int_t[fNLayers];
@@ -500,7 +526,7 @@ TGeoPNEntry* AliITSUGeomTGeo::GetPNEntry(Int_t index) const
 }
 
 //______________________________________________________________________
-void AliITSUGeomTGeo::BuildITS()
+void AliITSUGeomTGeo::BuildITS(Bool_t loadSegm)
 {
   // exract upg ITS parameters from TGeo
   if (fVersion!=kITSVNA) {AliWarning("Already built"); return; // already initialized}
@@ -525,6 +551,11 @@ void AliITSUGeomTGeo::BuildITS()
   FetchMatrices();
   fVersion = kITSVUpg;
   //
+  if (loadSegm) {  // fetch segmentations
+    fSegm = new TObjArray();
+    AliITSUSegmentationPix::LoadSegmentations(fSegm,GetITSsegmentationFileName());
+  }
+  //
 }
 
 //______________________________________________________________________
index 6e54b93..4cf2827 100644 (file)
@@ -40,6 +40,7 @@
 
 class TGeoPNEntry;
 class TDatime;
+class AliITSsegmentation;
 
 class AliITSUGeomTGeo : public TObject {
 
@@ -47,7 +48,7 @@ class AliITSUGeomTGeo : public TObject {
   enum {kITSVNA, kITSVUpg}; // ITS version
   enum {kDetTypePix=0, kNDetTypes, kMaxSegmPerDetType=10}; // defined detector types (each one can have different segmentations)
   //
-  AliITSUGeomTGeo(Bool_t build = kFALSE);
+  AliITSUGeomTGeo(Bool_t build = kFALSE, Bool_t loadSegmentations = kTRUE);
   virtual ~AliITSUGeomTGeo(); 
   AliITSUGeomTGeo(const AliITSUGeomTGeo &src);
   AliITSUGeomTGeo& operator=(const AliITSUGeomTGeo &geom);
@@ -105,6 +106,9 @@ class AliITSUGeomTGeo : public TObject {
   Int_t  GetLayerDetTypeID(Int_t lr)                                         const;
   Int_t  GetModuleDetTypeID(Int_t id)                                        const;
   //
+  const AliITSsegmentation* GetSegmentationByID(Int_t id)                    const;
+  const AliITSsegmentation* GetSegmentation(Int_t lr)                        const;
+  TObjArray*          GetSegmentations()                                     const {return (TObjArray*)fSegm;}
   virtual void Print(Option_t *opt="")  const;
 
   static const char* GetITSVolPattern()                                 {return fgkITSVolName;}
@@ -137,9 +141,9 @@ class AliITSUGeomTGeo : public TObject {
   Int_t        ExtractNumberOfLadders(Int_t lay)                  const;
   Int_t        ExtractLayerDetType(Int_t lay)                     const;
   Int_t        ExtractNumberOfLayers()                            const;
-  void         BuildITS();
+  void         BuildITS(Bool_t loadSegm);
   //
- private:
+ protected:
   //
   //
   Int_t  fVersion;             // ITS Version 
@@ -152,6 +156,7 @@ class AliITSUGeomTGeo : public TObject {
   //
   TObjArray* fMatSens;         // Sensor's matrices pointers in the geometry
   TObjArray* fMatT2L;          // Tracking to Local matrices pointers in the geometry
+  TObjArray* fSegm;            // segmentations
   //
   static const char*  fgkITSVolName;             // ITS mother volume name
   static const char*  fgkITSLrName;              // ITS Layer name
@@ -300,4 +305,18 @@ inline const char* AliITSUGeomTGeo::GetDetTypeName(Int_t i)
   return fgkITSDetTypeName[i];
 }
 
+//_____________________________________________________________________________________________
+inline const AliITSsegmentation* AliITSUGeomTGeo::GetSegmentationByID(Int_t id) const 
+{
+  // get segmentation by ID
+  return fSegm ? (AliITSsegmentation*)fSegm->At(id) : 0;
+}
+
+//_____________________________________________________________________________________________
+inline const AliITSsegmentation* AliITSUGeomTGeo::GetSegmentation(Int_t lr) const 
+{
+  // get segmentation of layer
+  return fSegm ? (AliITSsegmentation*)fSegm->At( GetLayerDetTypeID(lr) ) : 0;
+}
+
 #endif
index d36da8d..c02a0c2 100644 (file)
@@ -13,14 +13,12 @@ AliITSURecoDet::AliITSURecoDet(const char* name)
   ,fRMin(-1)
   ,fLayers(0)
   ,fLayersActive(0)
-  ,fSegmentations(0)
   ,fITSGeom(0)
 {
   // def. c-tor
   SetNameTitle(name,name);
   fLayers.SetOwner(kTRUE);        // layers belong to this array
   fLayersActive.SetOwner(kFALSE); // this one just points on active layers in fLayers
-  fSegmentations.SetOwner(kTRUE); // segmentations are owned by the detector
 }
 
 //______________________________________________________
@@ -29,7 +27,6 @@ AliITSURecoDet::~AliITSURecoDet()
   // def. d-tor
   fLayersActive.Clear(); 
   fLayers.Clear();         // owned!
-  fSegmentations.Clear();  // owned!
   delete fITSGeom;
 }
 
@@ -59,11 +56,9 @@ Bool_t AliITSURecoDet::Build()
 {
   // build detector from TGeo
   //
-  fITSGeom = new AliITSUGeomTGeo(kTRUE);
+  fITSGeom = new AliITSUGeomTGeo(kTRUE,kTRUE);
   int nlr = fITSGeom->GetNLayers();
   if (!nlr) AliFatal("No geometry loaded");
-  AliITSUSegmentationPix::LoadSegmentations(&fSegmentations, fITSGeom->GetITSsegmentationFileName());
-  if (!fSegmentations.GetEntriesFast()) AliFatal(Form("Segmentations from %s are not loaded",fITSGeom->GetITSsegmentationFileName()));
   //
   // build active ITS layers
   for (int ilr=0;ilr<nlr;ilr++) {
@@ -71,11 +66,9 @@ Bool_t AliITSURecoDet::Build()
     int nLad = fITSGeom->GetNLadders(ilr);
     int nDet = fITSGeom->GetNDetectors(ilr);
     // name layer according its active id, detector type and segmentation tyoe
-    AliITSUSegmentationPix* segm = (AliITSUSegmentationPix*)fSegmentations.At(lrTyp);
-    if (!segm) { AliFatal(Form("Did not find segmentation type %d",lrTyp)); continue; }
     AliITSURecoLayer* lra = new AliITSURecoLayer( Form("Lr%d%s%d",ilr,fITSGeom->GetDetTypeName(lrTyp),
                                                       lrTyp%AliITSUGeomTGeo::kMaxSegmPerDetType),
-                                                 ilr,nLad*nDet,fITSGeom,segm);
+                                                 ilr,nLad*nDet,fITSGeom);
     lra->Build();
     AddLayer(lra);
   }
index c93d63f..79d3ad0 100644 (file)
@@ -5,7 +5,6 @@
 #include <TObjArray.h>
 #include "AliITSURecoLayer.h"
 class AliITSUGeomTGeo;
-class AliITSsegmentation;
 
 ///////////////////////////////////////////////////////////////////////
 //                                                                   //
@@ -30,7 +29,6 @@ class AliITSURecoDet : public TNamed
   AliITSURecoLayer*  GetLayer(Int_t i)             const;
   AliITSURecoLayer*  GetLayerActive(Int_t i)       const;
   AliITSUGeomTGeo*   GetGeom()                     const {return fITSGeom;}
-  TObjArray*         GetSegmentations()            const {return (TObjArray*)&fSegmentations;}
   //
   void               SetRMin(Double_t r)                 {fRMin = r;}
   void               SetRMax(Double_t r)                 {fRMax = r;}
@@ -47,8 +45,6 @@ class AliITSURecoDet : public TNamed
   Double_t           fRMin;           // min  R
   TObjArray          fLayers;         // layers
   TObjArray          fLayersActive;   // active layers
-  //
-  TObjArray          fSegmentations;
   AliITSUGeomTGeo*   fITSGeom;        // ITS geometry
   //
  private:
index 3f85b94..5fd3134 100644 (file)
@@ -28,7 +28,6 @@ AliITSURecoLayer::AliITSURecoLayer(const char* name)
   ,fDPhiLadInv(0)
   ,fSensors(0)
   ,fITSGeom(0)
-  ,fkSegm(0)
 {
   // def. c-tor
   SetNameTitle(name,name);
@@ -36,7 +35,7 @@ AliITSURecoLayer::AliITSURecoLayer(const char* name)
 }
 
 //______________________________________________________
-AliITSURecoLayer::AliITSURecoLayer(const char* name,Int_t activeID,Int_t nsens, AliITSUGeomTGeo* gm,const AliITSsegmentation* segm)
+AliITSURecoLayer::AliITSURecoLayer(const char* name,Int_t activeID,Int_t nsens, AliITSUGeomTGeo* gm)
   :fActiveID(activeID)
   ,fNSensors(0)
   ,fNSensInLadder(0)
@@ -53,7 +52,6 @@ AliITSURecoLayer::AliITSURecoLayer(const char* name,Int_t activeID,Int_t nsens,
   ,fDPhiLadInv(0)
   ,fSensors(nsens)
   ,fITSGeom(gm)
-  ,fkSegm(segm)
 {
   // def. c-tor
   SetNameTitle(name,name);
@@ -81,6 +79,7 @@ Bool_t AliITSURecoLayer::Build()
   // build internal structures
   fNLadders = fITSGeom->GetNLadders(fActiveID);
   fNSensInLadder = fITSGeom->GetNDetectors(fActiveID);
+  const AliITSsegmentation* kSegm = fITSGeom->GetSegmentation(fActiveID);
   //
   // name layer according its active id, detector type and segmentation tyoe
   TGeoHMatrix mmod;
@@ -104,11 +103,11 @@ Bool_t AliITSURecoLayer::Build()
       double phiMin=1e9,phiMax=-1e9,zMin=1e9,zMax=-1e9;
       mmod = *fITSGeom->GetMatrix(fActiveID,ild,idt);
       for (int ix=0;ix<2;ix++) {
-       loc[0] = (ix-0.5)*fkSegm->Dx(); // +-DX/2
+       loc[0] = (ix-0.5)*kSegm->Dx(); // +-DX/2
        for (int iy=0;iy<2;iy++) {
-         loc[1] = (iy-0.5)*fkSegm->Dy(); // +-DY/2
+         loc[1] = (iy-0.5)*kSegm->Dy(); // +-DY/2
          for (int iz=0;iz<2;iz++) {
-           loc[2] = (iz-0.5)*fkSegm->Dz(); // +-DZ/2
+           loc[2] = (iz-0.5)*kSegm->Dz(); // +-DZ/2
            //
            mmod.LocalToMaster(loc,glo);
            double phi = ATan2(glo[1],glo[0]);
index 435276e..ccf2264 100644 (file)
@@ -21,7 +21,7 @@ class AliITSURecoLayer : public TNamed
   //
   enum {kPassive=BIT(14)};
   AliITSURecoLayer(const char* name);
-  AliITSURecoLayer(const char* name, Int_t activeID,Int_t nsens,AliITSUGeomTGeo* gm,const AliITSsegmentation* segm);
+  AliITSURecoLayer(const char* name, Int_t activeID,Int_t nsens,AliITSUGeomTGeo* gm);
   virtual ~AliITSURecoLayer();
   //
   Bool_t             Build();
@@ -68,7 +68,6 @@ class AliITSURecoLayer : public TNamed
   Double_t           fDPhiLadInv;// inverse mean ladder dphi
   TObjArray          fSensors;   // sensors
   AliITSUGeomTGeo*   fITSGeom;   // geometry interface
-  const AliITSsegmentation* fkSegm;     // layer segmentation
   //
  private:
   AliITSURecoLayer(const AliITSURecoLayer &source); 
index 4085eae..24452fd 100644 (file)
@@ -41,7 +41,6 @@ ClassImp(AliITSUReconstructor)
 AliITSUReconstructor::AliITSUReconstructor() 
 :  AliReconstructor()
   ,fGM(0)
-  ,fSegmArr(0)
   ,fClusterFinders(0)
   ,fRecPoints(0)
 {
@@ -72,7 +71,6 @@ AliITSUReconstructor::~AliITSUReconstructor()
   }
   //
   delete fGM;
-  fSegmArr.Delete();
 } 
 
 //______________________________________________________________________
@@ -81,15 +79,13 @@ void AliITSUReconstructor::Init()
   // Initalize this constructor 
   if (fGM) AliFatal("was already done, something is wrong...");
   //
-  fGM = new AliITSUGeomTGeo(kTRUE);
-  AliITSUSegmentationPix::LoadSegmentations(&fSegmArr, AliITSUGeomTGeo::GetITSsegmentationFileName());
+  fGM = new AliITSUGeomTGeo(kTRUE,kTRUE);
   //  
   AliITSUClusterizer* clusPIX = 0;
   TClonesArray* rpArrayPix = 0;
   //
   for (int ilr=fGM->GetNLayers();ilr--;) {
-    int tp = fGM->GetLayerDetTypeID(ilr);
-    int tpDet = tp/AliITSUGeomTGeo::kMaxSegmPerDetType;
+    int tpDet = fGM->GetLayerDetTypeID(ilr)/AliITSUGeomTGeo::kMaxSegmPerDetType;
     if (tpDet == AliITSUGeomTGeo::kDetTypePix) {
       if (!clusPIX)    clusPIX    = new AliITSUClusterizer();
       if (!rpArrayPix) rpArrayPix = new TClonesArray(AliCluster::Class());
@@ -97,8 +93,8 @@ void AliITSUReconstructor::Init()
       fClusterFinders.AddAtAndExpand(clusPIX, ilr);
       fRecPoints.AddAtAndExpand(rpArrayPix, ilr);
       //
-      AliITSUSegmentationPix* sg = (AliITSUSegmentationPix*)fSegmArr.At(tp);
-      clusPIX->SetSegmentation(sg); // to expand the buffers to max.size
+      // to expand the buffers to max.size
+      clusPIX->SetSegmentation((AliITSUSegmentationPix*)fGM->GetSegmentation(ilr)); 
       continue;
     }
     else {
@@ -140,11 +136,8 @@ void AliITSUReconstructor::Reconstruct(TTree *digitsTree, TTree *clustersTree) c
   //
   for (int ilr=0;ilr<fGM->GetNLayers();ilr++) {
     //
-    int tp = fGM->GetLayerDetTypeID(ilr)/AliITSUGeomTGeo::kMaxSegmPerDetType;
-    AliITSUSegmentationPix* segm = (AliITSUSegmentationPix*)fSegmArr.At(tp);
-    //
     clFinder = (AliITSUClusterizer*)fClusterFinders[ilr];
-    clFinder->SetSegmentation(segm);
+    clFinder->SetSegmentation((AliITSUSegmentationPix*)fGM->GetSegmentation(ilr));
     clFinder->SetClusters(rpClones[ilr]);
     //
     int modF=fGM->GetFirstModIndex(ilr);
index 0a7b34d..0eb3ad5 100644 (file)
@@ -39,8 +39,7 @@ private:
   AliITSUReconstructor(const AliITSUReconstructor &); //Not implemented
   AliITSUReconstructor& operator=(const AliITSUReconstructor &); //Not implemented
 
-  AliITSUGeomTGeo* fGM;   // geometry wrapper
-  TObjArray        fSegmArr;     // Array of different pixel segmentations
+  AliITSUGeomTGeo* fGM;          // geometry wrapper
   TObjArray        fClusterFinders; // array of clusterfinders per layer
   TObjArray        fRecPoints;      // container for recpoints TClonesArrays
   //
index f35342b..ca60f07 100644 (file)
@@ -17,9 +17,7 @@ void readDigits(){
   runLoader->LoadDigits();
 
   AliGeomManager::LoadGeometry("geometry.root");
-  AliITSUGeomTGeo* gm = new AliITSUGeomTGeo(kTRUE);
-  TObjArray segmArr;
-  AliITSUSegmentationPix::LoadSegmentations(&segmArr, AliITSUGeomTGeo::GetITSsegmentationFileName());
+  AliITSUGeomTGeo* gm = new AliITSUGeomTGeo(kTRUE,kTRUE);
   //
   Int_t nLayers = gm->GetNLayers();
   Int_t nModules = gm->GetNModules();
@@ -64,7 +62,7 @@ void readDigits(){
       sDigTree->GetEntry(imod);
       digTree->GetEntry(imod);      
       int detType = gm->GetModuleDetTypeID(imod);
-      AliITSUSegmentationPix* segm = (AliITSUSegmentationPix*)segmArr.At(detType);
+      AliITSUSegmentationPix* segm = (AliITSUSegmentationPix*)gm->GetSegmentationByID(detType);
       int lay,lad,det;
       int nsdig = sDigArr->GetEntries();
       int ndig  = digArr->GetEntries();
index 0426025..fa780ee 100644 (file)
@@ -22,10 +22,8 @@ void drawLr(int layMin=1,int layMax=1)
   AliGeomManager::ApplyAlignObjsToGeom(*array);
   gGeoManager->LockGeometry();
 
-  AliITSUGeomTGeo* gm = new AliITSUGeomTGeo(kTRUE);
-  TObjArray segmArr;
-  AliITSUSegmentationPix::LoadSegmentations(&segmArr, AliITSUGeomTGeo::GetITSsegmentationFileName());
-  
+  AliITSUGeomTGeo* gm = new AliITSUGeomTGeo(kTRUE,kTRUE);
+  TObjArray* segmArr = gm->GetSegmentations();  
   //
   int nlr = gm->GetNLayers();
   if (layMin<0) layMin = 0;
@@ -44,7 +42,7 @@ void drawLr(int layMin=1,int layMax=1)
 
   for (Int_t lay=layMin;lay<=layMax;lay++) {
     //
-    AliITSUSegmentationPix* segm = (AliITSUSegmentationPix*)segmArr.At(gm->GetLayerDetTypeID(lay));
+    AliITSUSegmentationPix* segm = (AliITSUSegmentationPix*)segmArr->At(gm->GetLayerDetTypeID(lay));
     for (int ild=0;ild<gm->GetNLadders(lay);ild++) {
     
       // Sensor Matrices