Updates concerning the geometry: versioning system, new V11hybrid version, bug fixes...
authormasera <masera@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 8 May 2007 16:57:42 +0000 (16:57 +0000)
committermasera <masera@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 8 May 2007 16:57:42 +0000 (16:57 +0000)
32 files changed:
ITS/AliITS.cxx
ITS/AliITS.h
ITS/AliITSCompareHitsRecPoints.C [new file with mode: 0644]
ITS/AliITSInitGeometry.cxx
ITS/AliITSInitGeometry.h
ITS/AliITSPrintRecPoints.C
ITS/AliITSRecPoint.cxx
ITS/AliITSgeom.cxx
ITS/AliITSgeom.h
ITS/AliITSgeomMatrix.cxx
ITS/AliITSgeomMatrix.h
ITS/AliITShit.cxx
ITS/AliITShit.h
ITS/AliITSv11.cxx
ITS/AliITSv11.h
ITS/AliITSv11Hybrid.cxx
ITS/AliITSv11Hybrid.h
ITS/AliITSvBeamTestITS04.cxx
ITS/AliITSvBeamTestITS04.h
ITS/AliITSvPPRasymmFMD.cxx
ITS/AliITSvPPRasymmFMD.h
ITS/AliITSvPPRcoarseasymm.cxx
ITS/AliITSvPPRcoarseasymm.h
ITS/AliITSvSDD03.cxx
ITS/AliITSvSDD03.h
ITS/AliITSvSPD02.cxx
ITS/AliITSvSPD02.h
ITS/AliITSvSSD03.cxx
ITS/AliITSvSSD03.h
ITS/AliITSvtest.cxx
ITS/AliITSvtest.h
ITS/Displayv11.C

index 852f7075e7280ccee8a08e906bfdd93187cdf92c..84bb1ac1d87afeb3b371237d1924decada56caf7 100644 (file)
@@ -107,7 +107,8 @@ fOpt("All"),
 fIdN(0),
 fIdSens(0),
 fIdName(0),
-fITSmodules(0)
+fITSmodules(0),
+fTiming(kFALSE)
 {
   // Default initializer for ITS
   //      The default constructor of the AliITS class. In addition to
@@ -120,6 +121,42 @@ fITSmodules(0)
 //PH    SetMarkerColor(kRed);
 }
 //______________________________________________________________________
+AliITS::AliITS(const Char_t *title):AliDetector("ITS",title),
+fDetTypeSim(0),
+fEuclidOut(0),
+fOpt("All"),
+fIdN(0),
+fIdSens(0),
+fIdName(0),
+fITSmodules(0),
+fTiming(kFALSE)
+{
+    //     The standard Constructor for the ITS class. 
+    // It also zeros the variables
+    // fIshunt (a member of AliDetector class), fEuclidOut, 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.
+    // Inputs:
+    //   Char_t *title  Simulation title for the ITS
+    // Outputs:
+    //   none.
+    // Return:
+    //   none.
+  
+    fHits = new TClonesArray("AliITShit",1560); // from AliDetector
+    if(gAlice->GetMCApp()) gAlice->GetMCApp()->AddHitList(fHits);
+    //fNhits=0;  //done in AliDetector(name,title)
+    SetDetectors(); // default to fOpt="All". This variable not written out.
+    fDetTypeSim   = new AliITSDetTypeSim();
+    //PH  SetMarkerColor(kRed);
+    if(!fLoader) MakeLoader(AliConfig::GetDefaultEventFolderName());
+    fDetTypeSim->SetLoader((AliITSLoader*)fLoader);
+}
+//______________________________________________________________________
 AliITS::AliITS(const char *name, const char *title):AliDetector(name,title),
 fDetTypeSim(0),
 fEuclidOut(0),
@@ -127,7 +164,8 @@ fOpt("All"),
 fIdN(0),
 fIdSens(0),
 fIdName(0),
-fITSmodules(0)
+fITSmodules(0),
+fTiming(kFALSE)
 {
   //     The standard Constructor for the ITS class. 
   // It also zeros the variables
@@ -1239,12 +1277,13 @@ Bool_t AliITS::Raw2SDigits(AliRawReader* rawReader)
 void AliITS::UpdateInternalGeometry(){
 
   //reads new geometry from TGeo 
-  AliDebug(1,"Delete ITSgeom and create a new one reading TGeo");
+//   AliDebug(1,"Delete ITSgeom and create a new one reading TGeo");
+
   AliITSVersion_t version = (AliITSVersion_t)IsVersion();
   Int_t minor = 0;
-  if(version==kvPPRasymmFMD)minor=2;  // default minor version for this geom.
-  AliITSInitGeometry initgeom(version,minor);
-  AliITSgeom* geom = initgeom.CreateAliITSgeom();
+  if(version==kvPPRasymmFMD) minor=2;  // default minor version for this geom.
+  AliITSInitGeometry initgeom;
+  AliITSgeom* geom = initgeom.CreateAliITSgeom(version,minor);
   SetITSgeom(geom);
 }
 
index e43a5b4a729dc9e2d6c16fb6b06d682a9d1b235f..0e761f5d62704d97c90d28ddc972646cede349fc 100644 (file)
@@ -36,7 +36,8 @@ class AliITS : public AliDetector {
  public:
     //================= Standard Classes ===============================
     AliITS();  // Default creator.
-    AliITS(const char *name, const char *title); // standard Creator
+    AliITS(const Char_t *title); // standard Creator
+    AliITS(const char *name, const char *title); // extended standard Creator
     virtual ~AliITS(); // destructor
     virtual Int_t IsVersion() const {return 1;}
     virtual Int_t DistancetoPrimitive(Int_t , Int_t )  {return 999;}
@@ -156,11 +157,12 @@ class AliITS : public AliDetector {
     Int_t        *fIdSens;     //[fIdN] layer identifier
     TString      *fIdName;     //[fIdN] layer identifier
     TObjArray    *fITSmodules; //! Pointer to ITS modules
+    Bool_t        fTiming;     // flag to turn on/off timers.
 
  private:
     AliITS(const AliITS &source); // copy constructor. Not to be used!
     AliITS& operator=(const AliITS &source); // = operator. Not to be used!
-    ClassDef(AliITS,6) // Base class for ITS
+    ClassDef(AliITS,7) // Base class for ITS
 
 };
 
diff --git a/ITS/AliITSCompareHitsRecPoints.C b/ITS/AliITSCompareHitsRecPoints.C
new file mode 100644 (file)
index 0000000..f5a10e4
--- /dev/null
@@ -0,0 +1,196 @@
+Bool_t AliITSCompareHitsRecPoints(Char_t *rfn="galice.root"){
+    // This macro compares the average location of the hits associated
+    // with a specific track and the best match RecPoint location.
+    // Inputs:
+    //   none.
+    // Outputs:
+    //   none.
+    // Return:
+    //   kTRUE if no errors were encountered, otherwise kFALSE.
+    TProfile *pxg,*pyg,*pzg,*pxl,*pyl,*pzl;
+    Double_t hg[3],hl[3],tof,rg[3],rl[3];
+    Float_t rgf[3];
+
+    // Dynamically link some shared libs
+    if (gClassTable->GetID("AliRun") < 0) {
+        gROOT->LoadMacro("loadlibs.C");
+        loadlibs();
+    } else {
+        if(gAlice){
+            delete gAlice->GetRunLoader();
+            delete gAlice;
+            gAlice=0;
+        } // end if gAlice
+    }// end if gClassTable->GetID()
+
+    gROOT->LoadMacro("$(ALICE_ROOT)/ITS/AliITSstandard.C");
+
+    AliRunLoader *runl = AccessFile(rfn); // Set up to read in Data
+    Int_t retval = runl->LoadHeader();
+    if (retval){
+        cerr<<"AliITSPrintRecPoints.C : LoadHeader returned error"<<endl;
+        return kFALSE;
+    } // end if retval
+
+    AliITSLoader* ITSloader =  (AliITSLoader*) runl->GetLoader("ITSLoader");
+    if(!ITSloader){
+        cerr<<"AliITSPrintRecPoints.C :  ITS loader not found"<<endl;
+        return kFALSE;
+    } // end if !ITSloader
+
+    if(!gGeoManager){
+        gGeoManger = new TGeoManager();
+        gGeoManager->Import("geometry.root","");
+    } // end if !gGeoManager
+    if(ITSloader->LoadHits("read")!=0){
+        cerr<<"Error Loading Hits"<<endl;
+        return kFALSE;
+    }// end if ITSloader->LoadHits
+    if(ITSloader->LoadRecPoints("read")!=0){
+        cerr<<"Error Loading RecPoints"<<endl;
+        return kFALSE;
+    }// end if ITSloader->LoadRecPoints
+    AliITS *ITS = 0;
+    ITS = (AliITS*)(gAlice->GetDetector("ITS"));
+    if(!ITS){
+        cout << "Error: no ITS found. Aborting"<<endl;
+        return kFALSE;
+    } // end if !ITS
+    if(!(ITS->GetDetTypeSim())){
+        cout <<"No AliITSDetTypeSim object found in ITS"<<endl;
+        return kFALSE;
+    } // end if
+    AliITSmodule     *m   = 0;
+    AliITShit        *h   = 0;
+    AliITSDetTypeSim *sim = ITS->GetDetTypeSim();
+    AliITSgeom *gm=0;
+    gm = ITS->GetITSgeom();
+    if(!gm){
+        cout <<"No AliITSgeom object found in ITS"<<endl;
+        if(!gGeoManager){
+            cout <<"No gGeoManger. Aborting"<<endl;
+            return kFALSE;
+        }else{
+            ITS->UpdateInternalGeometry(gGeoManager);
+        } // end if
+    } // end if !AliITSgeom
+    //
+    Int_t nMods= gm->GetIndexMax(),nEvents=gAlice->GetEventsPerRun();
+    Int_t mod=0,evnt=0,size=-1,irp=0,ih=0,trkindexOld=-1;
+    Double_t xmod,nHitPerTrack;
+    TTree            *rpt = 0;
+    TClonesArray     *rpa = 0;
+    AliITSRecPoint   *rp  = 0;
+    AliITSDetTypeRec *rec = new AliITSDetTypeRec(ITSloader);
+    rec->SetDefaults();
+    // We are going to use the following
+    // <hit_x[i]> == { Sum_j hit_x[i][j] }/N_hits per track
+    // d_x[i] == <hit_x[i]>-recpoint_x[i]
+    // <d_x>  == {sum_i d_x[i]}/N_RecPoints   (excluding noise and no merging)
+    //         = {sum_i (<hit_x[i]>-recpoint_x[i])}/N_RecPoints
+    //         = {sum_i ((sum_j hit_x[i][j])/N_hits_per_track -recpoinnt_x[i])}/N_Recpoints
+    //         = sum_i sum_j {hit_x[i][j]/N_hits_per_track}/N_Recpoints -
+    //           sum_i {recpoint_x[i]}/N_Recpoints
+    pxg = new TProfile("XdiffGlobal","Mean displacement in gX direction",nMods,
+                       -0.5,(Double_t)(nMods)+0.5," ");
+    pxg->SetXTitle("module");
+    pxg->SetYTitle("Global X [cm]");
+    pyg = new TProfile("YdiffGlobal","Mean displacement in gY direction",nMods,
+                       -0.5,(Double_t)(nMods)+0.5," ");
+    pyg->SetXTitle("module");
+    pyg->SetYTitle("Global Y [cm]");
+    pzg = new TProfile("ZdiffGlobal","Mean displacement in gZ direction",nMods,
+                       -0.5,(Double_t)(nMods)+0.5," ");
+    pzg->SetXTitle("module");
+    pzg->SetYTitle("Global Z [cm]");
+    pxl = new TProfile("XdiffLocal","Mean displacement in lX direction",nMods,
+                       -0.5,(Double_t)(nMods)+0.5," ");
+    pxl->SetXTitle("module");
+    pxl->SetYTitle("local X [cm]");
+    pyl = new TProfile("YdiffLocal","Mean displacement in lY direction",nMods,
+                       -0.5,(Double_t)(nMods)+0.5," ");
+    pyl->SetXTitle("module");
+    pyl->SetYTitle("local Y [cm]");
+    pzl = new TProfile("ZdiffLocal","Mean displacement in lZ direction",nMods,
+                       -0.5,(Double_t)(nMods)+0.5," ");
+    pzl->SetXTitle("module");
+    pzl->SetYTitle("local Z [cm]");
+    //
+    for(evnt=0;evnt<nEvents;evnt++){
+        runl->GetEvent(evnt);
+        ITS->InitModules(size,nMods);
+        ITS->FillModules(evnt,0,-1," "," ");
+        rec->SetTreeAddress();
+        for(mod=0;mod<nMods;mod++){
+            xmod = (Double_t) mod;
+            m = ITS->GetModule(mod);
+            rec->ResetRecPoints();
+            rpt = ITSloader->TreeR();
+            rpt->GetEvent(mod);
+            rpa = rec->RecPoints();
+            for(irp=0;irp<rpa->GetEntriesFast();irp++){
+                rp = (AliITSRecPoint*)(rpa->At(irp));
+                rp->GetGlobalXYZ(rgf);rg[0]=rgf[0];rg[1]=rgf[1];rg[2]=rgf[2];
+                rl[0] = rp->GetDetLocalX();
+                rl[1] = 0.0;
+                rl[2] = rp->GetDetLocalZ();
+                pxg->Fill(xmod,-rg[0],0.5);
+                pyg->Fill(xmod,-rg[1],0.5);
+                pzg->Fill(xmod,-rg[2],0.5);
+                pxl->Fill(xmod,-rl[0],0.5);
+                //pyl->Fill(xmod,-rl[1],0.5); // assumed to be zero always.
+                pzl->Fill(xmod,-rl[2],0.5);
+            }// rnf got itp
+            trkindexOld=-1;
+            nHitPerTrack = 0.0;
+            for(ih=0;ih<m->GetNhits();ih++){ // We want the median hit location
+                // for each track.
+                h = m->GetHit(ih);
+                if(m->GetHitTrackIndex(ih)!=trkindexOld){// Enterence location
+                    trkindexOld = m->GetHitTrackIndex(ih);
+                    nHitPerTrack = 1.0;
+                    do{
+                        nHitPerTrack += 1.0;
+                    }while (m->GetHitTrackIndex(ih+nHitPerTrack-1)==trkindexOld);
+                    h->GetPositionG0(hg[0],hg[1],hg[2],tof);
+                    h->GetPositionL0(hl[0],hl[1],hl[2],tof);
+                    pxg->Fill(xmod,hg[0],0.5/nHitPerTrack);
+                    pyg->Fill(xmod,hg[1],0.5/nHitPerTrack);
+                    pzg->Fill(xmod,hg[2],0.5/nHitPerTrack);
+                    pxl->Fill(xmod,hl[0],0.5/nHitPerTrack);
+                    pyl->Fill(xmod,hl[1],1.0/nHitPerTrack); // rl[1]=0 always.
+                    pzl->Fill(xmod,hl[2],0.5/nHitPerTrack);
+                } // end if
+                if(nHitPerTrack==0.0) continue;
+                h->GetPositionG(hg[0],hg[1],hg[2],tof);
+                h->GetPositionL(hl[0],hl[1],hl[2],tof);
+                pxg->Fill(xmod,hg[0],0.5/nHitPerTrack);
+                pyg->Fill(xmod,hg[1],0.5/nHitPerTrack);
+                pzg->Fill(xmod,hg[2],0.5/nHitPerTrack);
+                pxl->Fill(xmod,hl[0],0.5/nHitPerTrack);
+                pyl->Fill(xmod,hl[1],1.0/nHitPerTrack); // rl[1]=0 always.
+                pzl->Fill(xmod,hl[2],0.5/nHitPerTrack);
+            } // end for ih
+        } // end for mod
+        ITS->ClearModules();
+    } // end for evnt
+    //
+    Int_t wh=800;
+    TCanvas *c0 = new TCanvas("c0","Average displacements between hits and RecPoints"
+                              ,1.5*wh,wh);
+    c0->Divide(3,2);
+    c0->cd(1);
+    pxg->Draw();
+    c0->cd(2);
+    pyg->Draw();
+    c0->cd(3);
+    pzg->Draw();
+    c0->cd(4);
+    pxl->Draw();
+    c0->cd(5);
+    pyl->Draw();
+    c0->cd(6);
+    pzl->Draw();
+    c0->Update();
+    return kTRUE;
+}
index 4cb0249729ba32442929d292c0a92e63754d23fb..f536fa847b183f0f1ba72100b58d3b764758d866 100644 (file)
@@ -52,6 +52,7 @@ $Id$
 #include "AliITSsegmentationSSD.h"
 #include "AliITSgeom.h"
 #include "AliITSInitGeometry.h"
+#include <TDatime.h>
 
 ClassImp(AliITSInitGeometry)
 
@@ -65,16 +66,18 @@ const Bool_t AliITSInitGeometry::fgkOldSDDshield = kTRUE;
 const Bool_t AliITSInitGeometry::fgkOldSSDshield = kTRUE;
 const Bool_t AliITSInitGeometry::fgkOldServices  = kTRUE;
 const Bool_t AliITSInitGeometry::fgkOldSupports  = kTRUE;
-/*
 //______________________________________________________________________
 AliITSInitGeometry::AliITSInitGeometry():
-TObject(),
-fName(),
-fMinorVersion(0),
-fMajorVersion(0),
-fTiming(kFALSE),
-fSegGeom(kFALSE),
-fDecode(kFALSE){
+TObject(),                   // Base Class
+fName(0),                    // Geometry name
+fMinorVersion(-1),           // Minor version number/type
+fMajorVersion(kvDefault),    // Major versin number
+fTiming(kFALSE),             // Flag to start inilization timing
+fSegGeom(kFALSE),            // Flag to switch between the old use of
+                             // AliITSgeomS?D class, or AliITSsegmentation
+                             // class in fShape of AliITSgeom class.
+fDecode(kFALSE),             // Flag for new/old decoding
+fDebug(0){                   // Debug flag
     // Default Creator
     // Inputs:
     //   none.
@@ -82,17 +85,22 @@ fDecode(kFALSE){
     //   none.
     // Return:
     //   A default inilized AliITSInitGeometry object
+
+    fName = "Undefined";
 }
-*/
 //______________________________________________________________________
-AliITSInitGeometry::AliITSInitGeometry(AliITSVersion_t version,Int_t minorversion):
-TObject(),
-fName(0),
-fMinorVersion(minorversion),
-fMajorVersion(version),
-fTiming(kFALSE),
-fSegGeom(kFALSE),
-fDecode(kFALSE){
+AliITSInitGeometry::AliITSInitGeometry(AliITSVersion_t version,
+                                       Int_t minorversion):
+TObject(),                   // Base Class
+fName(0),                    // Geometry name
+fMinorVersion(minorversion), // Minor version number/type
+fMajorVersion(version),      // Major versin number
+fTiming(kFALSE),             // Flag to start inilization timing
+fSegGeom(kFALSE),            // Flag to switch between the old use of
+                             // AliITSgeomS?D class, or AliITSsegmentation
+                             // class in fShape of AliITSgeom class.
+fDecode(kFALSE),             // Flag for new/old decoding
+fDebug(0){                   // Debug flag
     // Default Creator
     // Inputs:
     //   none.
@@ -100,34 +108,16 @@ fDecode(kFALSE){
     //   none.
     // Return:
     //   A default inilized AliITSInitGeometry object
-  if(version == kvPPRasymmFMD && (fMinorVersion==1|| fMinorVersion==2)){
-    fName="AliITSvPPRasymmFMD";
-  }
-  else if(version == kv11Hybrid){
-    fName="AliITSv11Hybrid";
-  }
-  else {
-    AliFatal(Form("Undefined geometry: fMajorVersion=%d, fMinorVersion= %d",(Int_t)fMajorVersion,fMinorVersion));
-  }
-  /*
-
-    if(fName.CompareTo("AliITSvPPRasymmFMD")==0)if(fMinorVersion==1||
-                                                  fMinorVersion==2) {
-       fMajorVersion=10;
-       return;
-    } // end if
 
-    if (fName.CompareTo("AliITSv11")==0) {
-       fMajorVersion=11;
-       return;
+    if(version == kvPPRasymmFMD && (fMinorVersion==1|| fMinorVersion==2)){
+        fName="AliITSvPPRasymmFMD";
+    }else if(version == kv11Hybrid){
+        fName="AliITSv11Hybrid";
+    }else {
+        AliFatal(Form("Undefined geometry: fMajorVersion=%d, "
+                      "fMinorVersion= %d",(Int_t)fMajorVersion,fMinorVersion));
+        fName = "Undefined";
     } // end if
-
-    // if not defined geometry error
-    Error("AliITSInitGeometry(name,version)"," Name must be AliITSvPPRasymmFMD"
-       " and version must be 1 or 2 for now.");
-    fMinorVersion = 0;
-    fName = "";
-  */
     return;
 }
 //______________________________________________________________________
@@ -144,6 +134,84 @@ AliITSgeom* AliITSInitGeometry::CreateAliITSgeom(){
     //   A pointer to a new properly inilized AliITSgeom class. If
     //   pointer = 0 then failed to init.
 
+
+  AliITSVersion_t version = kvDefault;
+  Int_t minor = 0;
+  TDatime datetime;
+  TGeoVolume *itsV = gGeoManager->GetVolume("ITSV");
+  if(!itsV){
+    Error("CreateAliITSgeom","Can't find ITS volume ITSV, aborting");
+    return 0;
+  }// end if
+  const Char_t *title = itsV->GetTitle();
+  if(!ReadVersionString(title,(Int_t)strlen(title),version,minor,
+                       datetime))
+    Warning("UpdateInternalGeometry","Can't read title=%s\n",title);
+  SetTiming(kFALSE);
+  SetSegGeom(kFALSE);
+  SetDecoding(kFALSE);
+  AliITSgeom *geom = CreateAliITSgeom(version,minor);
+  AliDebug(1,"AliITSgeom object has been initialized from TGeo\n");
+  return geom;
+}
+//______________________________________________________________________
+AliITSgeom* AliITSInitGeometry::CreateAliITSgeom(Int_t major,Int_t minor){
+    // Creates and Initilizes the geometry transformation class AliITSgeom
+    // to values appropreate to this specific geometry. Now that
+    // the segmentation is part of AliITSgeom, the detector
+    // segmentations are also defined here.
+    // Inputs:
+    //   Int_t major   major version, see AliITSVersion_t
+    //   Int_t minor   minor version
+    // Outputs:
+    //   none.
+    // Return:
+    //   A pointer to a new properly inilized AliITSgeom class. If
+    //   pointer = 0 then failed to init.
+
+    switch(major){
+    case kvtest:
+        SetGeometryName("AliITSvtest");
+        SetVersion(kvtest,minor);
+        break;
+    case kvSPD02:
+        SetGeometryName("AliITSvSPD02");
+        SetVersion(kvSPD02,minor);
+        break;
+    case kvSDD03:
+        SetGeometryName("AliITSvSDD03");
+        SetVersion(kvSDD03,minor);
+        break;
+    case kvSSD03:
+        SetGeometryName("AliITSvSSD03");
+        SetVersion(kvSSD03,minor);
+        break;
+    case kvITS04:
+        SetGeometryName("AliITSvBeamTest03");
+        SetVersion(kvITS04,minor);
+        break;
+    case kvPPRcourseasymm:
+        SetGeometryName("AliITSvPPRcourseasymm");
+        SetVersion(kvPPRcourseasymm,minor);
+        break;
+    case kvPPRasymmFMD:
+        SetGeometryName("AliITSvPPRasymmFMD");
+        SetVersion(kvPPRasymmFMD,minor);
+        break;
+    case kv11:
+        SetGeometryName("AliITSv11");
+        SetVersion(kv11,minor);
+        break;
+    case kv11Hybrid:
+        SetGeometryName("AliITSv11Hybrid");
+        SetVersion(kv11Hybrid,minor);
+        break;
+    case kvDefault:
+    default:
+        SetGeometryName("Undefined");
+        SetVersion(kvDefault,minor);
+        break;
+    } // end switch
     AliITSgeom *geom = new AliITSgeom();
     if(!InitAliITSgeom(geom)){ // Error initilization failed
        delete geom;
@@ -164,30 +232,459 @@ Bool_t AliITSInitGeometry::InitAliITSgeom(AliITSgeom *geom){
   // Return:
   //   none.
 
-  if(!gGeoManager){
-    AliFatal("The geometry manager has not been initialized (e.g. TGeoManager::Import(\"geometry.root\")should be called in advance) - exit forced");
+    if(!gGeoManager){
+        AliFatal("The geometry manager has not been initialized (e.g. "
+                 "TGeoManager::Import(\"geometry.root\")should be "
+                 "called in advance) - exit forced");
+        return kFALSE;
+    } // end if
+    switch(fMajorVersion) {
+    case kvtest: {
+        if(GetMinorVersion()==1) return InitAliITSgeomPPRasymmFMD(geom);
+        else if(GetMinorVersion()==2) return InitAliITSgeomtest2(geom);
+    } break; // end case
+    case kvSPD02: { 
+        return InitAliITSgeomSPD02(geom);
+    } break; // end case
+    case kvSDD03: { 
+        return InitAliITSgeomSDD03(geom);
+    } break; // end case
+    case kvSSD03: { 
+        return InitAliITSgeomSSD03(geom);
+    } break; // end case
+    case kvITS04: { 
+        return InitAliITSgeomITS04(geom);
+    } break; // end case
+    case kvPPRasymmFMD: { 
+        return InitAliITSgeomPPRasymmFMD(geom);
+    } break; // end case
+    case kvPPRcourseasymm: { 
+        return kTRUE; // No sensitive detectors in course geometry
+    } break; // end case
+    case kv11Hybrid: { 
+        return InitAliITSgeomV11Hybrid(geom);
+    } break; // end case
+    case kv11: {
+        return InitAliITSgeomV11(geom);
+    } break; // end case
+    case kvDefault: default: {
+        AliFatal("Undefined geometry");
+        return kFALSE;
+    } break; // end case
+    } // end switch
     return kFALSE;
-  }
-  switch(fMajorVersion) {
+}
+//______________________________________________________________________
+void AliITSInitGeometry::TransposeTGeoHMatrix(TGeoHMatrix *m)const{
+    // Transpose the rotation matrix part of a TGeoHMatrix. This
+    // is needed because TGeo stores the transpose of the rotation
+    // matrix as compared to what AliITSgeomMatrix uses (and Geant3).
+    // Inputs:
+    //    TGeoHMatrix *m  The matrix to be transposed
+    // Outputs:
+    //    TGEoHMatrix *m  The transposed matrix
+    // Return:
+    //    none.
+    Int_t i;
+    Double_t r[9];
+
+    if(m==0) return; // no matrix to transpose.
+    for(i=0;i<9;i += 4) r[i] = m->GetRotationMatrix()[i]; // diagonals
+    r[1] = m->GetRotationMatrix()[3];
+    r[2] = m->GetRotationMatrix()[6];
+    r[3] = m->GetRotationMatrix()[1];
+    r[5] = m->GetRotationMatrix()[7];
+    r[6] = m->GetRotationMatrix()[2];
+    r[7] = m->GetRotationMatrix()[5];
+    m->SetRotation(r);
+    return;
+}
+//______________________________________________________________________
+Bool_t AliITSInitGeometry::InitAliITSgeomtest2(AliITSgeom *geom){
+    // Initilizes the geometry transformation class AliITSgeom
+    // to values appropreate to this specific geometry. Now that
+    // the segmentation is part of AliITSgeom, the detector
+    // segmentations are also defined here.
+    // Inputs:
+    //   AliITSgeom *geom  A pointer to the AliITSgeom class
+    // Outputs:
+    //   AliITSgeom *geom  This pointer recreated and properly inilized.
+    // Return:
+    //   none.
+    //  const Double_t kcm2micron = 1.0E4;
+    const Int_t kItype=0; // Type of transormation defined 0=> Geant
+    const Int_t klayers = 6; // number of layers in the ITS
+    const Int_t kladders[klayers]   = {1,1,1,1,1,1}; // Number of ladders
+    const Int_t kdetectors[klayers] = {1,1,1,1,1,1};// number of detector/lad
+    const AliITSDetector kIdet[6]   = {kSPD,kSPD,kSDD,kSDD,kSSD,kSSD};
+    const TString kNames[klayers] = {
+        "/ALIC_1/ITSV_1/ITSspd1_1/ITS1_1", // lay=1
+        "/ALIC_1/ITSV_1/ITSspd2_1/ITS2_1", // lay=2
+        "/ALIC_1/ITSV_1/ITSsdd1_1/ITS3_1", // lay=3
+        "/ALIC_1/ITSV_1/ITSsdd2_1/ITS4_1", // lay=4
+        "/ALIC_1/ITSV_1/ITSssd1_1/ITS5_1", // lay=5
+        "/ALIC_1/ITSV_1/ITSssd2_1/ITS6_1"};// Lay=6
+    Int_t mod,nmods=0,lay,lad,det,cpn0,cpn1,cpn2;
+    Double_t tran[3]={0.0,0.0,0.0},rot[10]={9*0.0,1.0};
+    TArrayD shapePar;
+    TString shapeName;
+    TGeoHMatrix matrix;
+    Bool_t initSeg[3]={kFALSE,kFALSE,kFALSE};
+    TStopwatch *time = 0x0;if(fTiming) time=new TStopwatch();
+
+    if(fTiming) time->Start();
+    for(mod=0;mod<klayers;mod++) nmods += kladders[mod]*kdetectors[mod];
+    geom->Init(kItype,klayers,kladders,kdetectors,nmods);
+    for(mod=0;mod<nmods;mod++){
+        DecodeDetectorLayers(mod,lay,lad,det); // Write
+        geom->CreateMatrix(mod,lay,lad,det,kIdet[lay-1],tran,rot);
+        RecodeDetector(mod,cpn0,cpn1,cpn2); // Write reusing lay,lad,det.
+        geom->GetGeomMatrix(mod)->SetPath(kNames[lay-1]);
+        GetTransformation(kNames[lay-1].Data(),matrix);
+        geom->SetTrans(mod,matrix.GetTranslation());
+        TransposeTGeoHMatrix(&matrix); // Transpose TGeo's rotation matrixes
+        geom->SetRotMatrix(mod,matrix.GetRotationMatrix());
+        if(initSeg[kIdet[lay-1]]) continue;
+        GetShape(kNames[lay-1],shapeName,shapePar);
+        if(shapeName.CompareTo("BOX")){
+            Error("InitITSgeom2","Geometry changed without proper code update"
+                  "or error in reading geometry. Shape is not BOX shape is %s",
+                  shapeName.Data());
+            return kFALSE;
+        } // end if
+       InitGeomShapePPRasymmFMD(kIdet[lay-1],initSeg,shapePar,geom);
+    } // end for module
+    if(fTiming){
+        time->Stop();
+        time->Print();
+        delete time;
+    } // end if
+    return kTRUE;
+}
+//______________________________________________________________________
+Bool_t AliITSInitGeometry::InitAliITSgeomSPD02(AliITSgeom *geom){
+    // Initilizes the geometry transformation class AliITSgeom
+    // to values appropreate to this specific geometry. Now that
+    // the segmentation is part of AliITSgeom, the detector
+    // segmentations are also defined here.
+    // Inputs:
+    //   AliITSgeom *geom  A pointer to the AliITSgeom class
+    // Outputs:
+    //   AliITSgeom *geom  This pointer recreated and properly inilized.
+    // Return:
+    //   none.
+    const Int_t kltypess=2;
+    const Int_t knlayers=5;
+    const TString knames[kltypess]=
+        {"ALIC_1/ITSV_1/ITEL_%d/IMB0_1/IMBS_1",//lay=1,2,4,5
+         "ALIC_1/ITSV_1/IDET_%d/ITS0_1/ITST_1"};// lay=3
+    const Int_t kitsGeomTreeCopys[2]={4,1};
+    const Int_t knlad[knlayers]={knlayers*1},kndet[knlayers]={knlayers*1};
+    TString path,shapeName;
+    TGeoHMatrix matrix;
+    TArrayD shapePar;
+    TArrayF shapeParF;
+    Double_t trans[3]={3*0.0},rot[10]={10*0.0};
+    Int_t npar=3,mod,i,j,lay,lad,det,cpy;
+    Float_t par[20];
+    TStopwatch *time = 0x0;if(fTiming) time=new TStopwatch();
+
+    par[0]=0.64;par[1]=0.5*300.0E-4;par[2]=3.48;
+    mod=5;;
+    geom->Init(0,knlayers,knlad,kndet,mod);
+
+    if(fTiming) time->Start();
+    for(i=0;i<kltypess;i++)for(cpy=1;cpy<=kitsGeomTreeCopys[i];cpy++){
+        path.Form(knames[i].Data(),cpy);
+        GetTransformation(path.Data(),matrix);
+        GetShape(path.Data(),shapeName,shapePar);
+        shapeParF.Set(shapePar.GetSize());
+        for(j=0;j<shapePar.GetSize();j++) shapeParF[j]=shapePar[j];
+        lay = cpy;
+        if(i==0&&cpy>2) lay=cpy+1;
+        if(i==1) lay=3;
+        DecodeDetector(mod,kitsGeomTreeCopys[i],1,cpy,0);
+        DecodeDetectorLayers(mod,lay,lad,det);
+        geom->CreateMatrix(mod,lay,lad,det,kSPD,trans,rot);
+        geom->SetTrans(mod,matrix.GetTranslation());
+        geom->SetRotMatrix(mod,matrix.GetRotationMatrix());
+        geom->GetGeomMatrix(mod)->SetPath(path.Data());
+        if(!(geom->IsShapeDefined((Int_t)kSPD)))
+            geom->ReSetShape(kSPD,new AliITSgeomSPD425Short(npar,par));
+    } // end for i,cpy/
+    if(fTiming){
+        time->Stop();
+        time->Print();
+        delete time;
+    } // end if
+    return kTRUE;
+}
+//______________________________________________________________________
+Bool_t AliITSInitGeometry::InitAliITSgeomSDD03(AliITSgeom *geom){
+    // Initilizes the geometry transformation class AliITSgeom
+    // to values appropreate to this specific geometry. Now that
+    // the segmentation is part of AliITSgeom, the detector
+    // segmentations are also defined here.
+    // Inputs:
+    //   AliITSgeom *geom  A pointer to the AliITSgeom class
+    // Outputs:
+    //   AliITSgeom *geom  This pointer recreated and properly inilized.
+    // Return:
+    //   none
+    const Int_t knlayers=12;
+    //   const Int_t kndeep=6;
+    const Int_t kltypess=2;
+    const AliITSDetector kidet[knlayers]={kSSD,kSDD};
+    const TString knames[kltypess]={
+        "/ALIC_1/ITSV_1/ITEL_%d/ITAI_1/IMB0_1/IMBS_1",
+        "/ALIC_1/ITSV_1/IDET_%d/IDAI_1/ITS0_1/ITST_1"};
+    const Int_t kitsGeomTreeCopys[kltypess]={10,2};
+    const Int_t knp=384;
+    const Float_t kpitch=50.E-4;/*cm*/
+    Float_t box[3]={0.5*kpitch*(Float_t)knp,150.E-4,1.0},p[knp+1],n[knp+1];
+    Int_t nlad[knlayers]={knlayers*1};
+    Int_t ndet[knlayers]={knlayers*1};
+    Int_t mod=knlayers,lay=0,lad=0,det=0,i,j,cp0;
+    TString path,shapeName;
+    TGeoHMatrix matrix;
+    Double_t trans[3]={3*0.0},rot[10]={10*0.0};
+    TArrayD shapePar;
+    TArrayF shapeParF;
+    Bool_t isShapeDefined[kltypess]={kltypess*kFALSE};
+
+    geom->Init(0,knlayers,nlad,ndet,mod);
+    p[0]=-box[0];
+    n[0]=box[0];
+    // Fill in anode and cathode strip locations (lower edge)
+    for(i=1;i<knp;i++){
+        p[i] =p[i-1]+kpitch;
+        n[i] =n[i-1]-kpitch;
+    } // end for i
+    p[knp]=box[0];
+    n[knp]=-box[0];
+    for(i=0;i<kltypess;i++)for(cp0=1;cp0<=kitsGeomTreeCopys[i];cp0++){
+        DecodeDetector(mod,kitsGeomTreeCopys[i],cp0,1,2);
+        DecodeDetectorLayers(mod,lay,lad,det);
+        path.Form(knames[i].Data(),cp0);
+        GetTransformation(path.Data(),matrix);
+        GetShape(path.Data(),shapeName,shapePar);
+        shapeParF.Set(shapePar.GetSize());
+        for(j=0;j<shapePar.GetSize();j++)shapeParF[j]=shapePar[j];
+        geom->CreateMatrix(mod,lay,lad,det,kidet[i],trans,rot);
+        geom->SetTrans(mod,matrix.GetTranslation());
+        geom->SetRotMatrix(mod,matrix.GetRotationMatrix());
+        geom->GetGeomMatrix(mod)->SetPath(path.Data());
+        switch (kidet[i]){
+        case kSDD: if(!(geom->IsShapeDefined((Int_t)kSDD))){
+            geom->ReSetShape(kSDD,new AliITSgeomSDD256(shapeParF.GetSize(),
+                                                       shapeParF.GetArray()));
+            isShapeDefined[i]=kTRUE;
+        } break;
+        case kSSD:if(!(geom->IsShapeDefined((Int_t)kSSD))){
+            geom->ReSetShape(kSSD,new AliITSgeomSSD(box,0.0,0.0,
+                                                    knp+1,p,knp+1,n));
+            isShapeDefined[i]=kTRUE;
+        } break;
+        default:{} break;
+        } // end switch
+    } // end for i,cp0
+
+    return kTRUE;
+}
+//______________________________________________________________________
+Bool_t AliITSInitGeometry::InitAliITSgeomSSD03(AliITSgeom *geom){
+    // Initilizes the geometry transformation class AliITSgeom
+    // to values appropreate to this specific geometry. Now that
+    // the segmentation is part of AliITSgeom, the detector
+    // segmentations are also defined here.
+    // Inputs:
+    //   AliITSgeom *geom  A pointer to the AliITSgeom class
+    // Outputs:
+    //   AliITSgeom *geom  This pointer recreated and properly inilized.
+    // Return:
+    //   none.
+    const Int_t knlayers=5;
+    //   const Int_t kndeep=6;
+    const Int_t kltypess=3;
+    const AliITSDetector kIdet[knlayers]={kND,kSSD,kND};
+    const TString knames[kltypess]={
+        "/ALIC_1/ITSV_1/ITSA_%d/ITSS_1",
+        "/ALIC_1/ITSV_1/IGAR_%d/IAIR_1/ITST_1",
+        "/ALIC_1/ITSV_1/IFRA_%d/IFRS_1"};
+    const Int_t kitsGeomTreeCopys[kltypess]={3,1,1};
+    const Int_t kitsGeomDetTypes[kltypess]={1,2,3};
+    const Int_t knp=384;
+    const Float_t kpitch=50.E-4;//cm
+    Bool_t initSeg[3]={kFALSE, kFALSE, kFALSE};
+    Float_t box[3]={0.5*kpitch*(Float_t)knp,150.E-4,1.0},p[knp+1],n[knp+1];
+    Int_t nlad[knlayers]={knlayers*1};
+    Int_t ndet[knlayers]={knlayers*1};
+    Int_t mod=knlayers,lay=0,lad=0,det=0,i,j,cp0;
+    TString path,shapeName;
+    TGeoHMatrix matrix;
+    Double_t trans[3]={3*0.0},rot[10]={10*0.0};
+    TArrayD shapePar;
+    TArrayF shapeParF;
+    Bool_t isShapeDefined[kltypess]={kltypess*kFALSE};
+
+    geom->Init(0,knlayers,nlad,ndet,mod);
+    p[0]=-box[0];
+    n[0]=box[0];
+    // Fill in anode and cathode strip locations (lower edge)
+    for(i=1;i<knp;i++){
+        p[i] =p[i-1]+kpitch;
+        n[i] =n[i-1]-kpitch;
+    } // end for i
+    p[knp]=box[0];
+    n[knp]=-box[0];
+    for(i=0;i<kltypess;i++)for(cp0=1;cp0<=kitsGeomTreeCopys[i];cp0++){
+        DecodeDetector(mod,kitsGeomDetTypes[i],cp0,1,0);
+        DecodeDetectorLayers(mod,lay,lad,det);
+        path.Form(knames[i].Data(),cp0);
+        GetTransformation(path.Data(),matrix);
+        GetShape(path.Data(),shapeName,shapePar);
+        shapeParF.Set(shapePar.GetSize());
+        for(j=0;j<shapePar.GetSize();j++)shapeParF[j]=shapePar[j];
+        geom->CreateMatrix(mod,lay,lad,det,kIdet[i],trans,rot);
+        geom->SetTrans(mod,matrix.GetTranslation());
+        geom->SetRotMatrix(mod,matrix.GetRotationMatrix());
+        geom->GetGeomMatrix(mod)->SetPath(path.Data());
+        switch (kIdet[i]){
+        case kSSD:if(!(geom->IsShapeDefined((Int_t)kSSD))){
+            InitGeomShapePPRasymmFMD(kIdet[lay-1],initSeg,shapePar,geom);
+            isShapeDefined[i]=kTRUE;
+        } break;
+        default:{} break;
+        } // end switch
+    } // end for i,cp0
+
+    return kTRUE;
+}
+//______________________________________________________________________
+Bool_t AliITSInitGeometry::InitAliITSgeomITS04(AliITSgeom *geom){
+    // Initilizes the geometry transformation class AliITSgeom
+    // to values appropreate to this specific geometry. Now that
+    // the segmentation is part of AliITSgeom, the detector
+    // segmentations are also defined here.
+    // Inputs:
+    //   AliITSgeom *geom  A pointer to the AliITSgeom class
+    // Outputs:
+    //   AliITSgeom *geom  This pointer recreated and properly inilized.
+    // Return:
+    //   none.
+
+  // We can not use AliITSvBeamTestITS04::fgk... data members because
+  // AliITSInitGeometry is part of the base library while AliITSvBeamTestITS04
+  // is part of the simulation library. This would introduce a dependance
+  // between the 2 libraries
+
 
-  case kvPPRasymmFMD: { 
-    return InitAliITSgeomPPRasymmFMD(geom);
-  } break; // end case
+    const Int_t knlayers = 6;
+    Int_t nlad[knlayers], ndet[knlayers];
+    
+    nlad[0] = 1; ndet[0] = 2;
+    nlad[1] = 1; ndet[1] = 2;
+    nlad[2] = 1; ndet[2] = 1;
+    nlad[3] = 1; ndet[3] = 1;
+    nlad[4] = 1; ndet[4] = 2;
+    nlad[5] = 1; ndet[5] = 2;
 
-  case kv11Hybrid: { 
-    return InitAliITSgeomV11Hybrid(geom);
-  } break; // end case
+    Int_t nModTot = 10;
+    geom->Init(0,knlayers,nlad,ndet,nModTot);
 
-  case kv11: {
-    return InitAliITSgeomV11(geom);
-  } break; // end case
+    /*
+    //=== Set default shapes 
+    const Float_t kDxyzSPD[] = {AliITSvBeamTestITS04::fgkSPDwidthSens/2,
+                                AliITSvBeamTestITS04::fgkSPDthickSens/2,
+                                AliITSvBeamTestITS04::fgkSPDlengthSens/2};  
+    if(!(geom->IsShapeDefined(kSPD)))
+       geom->ReSetShape(kSPD,new AliITSgeomSPD425Short(3,(Float_t *)kDxyzSPD));
+    
+    const Float_t kDxyzSDD[] = {AliITSvBeamTestITS04::fgkSDDwidthSens/2.,
+                                AliITSvBeamTestITS04::fgkSDDthickSens/2.,
+                                AliITSvBeamTestITS04::fgkSDDlengthSens/2.};
+    if(!(geom->IsShapeDefined(kSDD)))
+       geom->ReSetShape(kSDD, new AliITSgeomSDD256(3,(Float_t *)kDxyzSDD));
+    
+    const Float_t kDxyzSSD[] = {AliITSvBeamTestITS04::fgkSSDlengthSens/2,
+                                AliITSvBeamTestITS04::fgkSSDthickSens/2,
+                                AliITSvBeamTestITS04::fgkSSDwidthSens/2};
+    if(!(geom->IsShapeDefined(kSSD)))
+       geom->ReSetShape(kSSD,new AliITSgeomSSD75and275(3,(Float_t *)kDxyzSSD));
+    
+    // Creating the matrices in AliITSgeom for each sensitive volume
+    // (like in AliITSv11GeometrySDD) mln
+    // Here, each layer is one detector
+    
+    char layerName[30];
+    Int_t startMod = 0,mod;
+    TGeoVolume *itsmotherVolume = gGeoManager->GetVolume("ITSV");
+    // SPD
+    for (Int_t i=0; i<4;i++) {
+       sprintf(layerName, "ITSspdWafer_%i",i+1);
+       TGeoNode *layNode = itsmotherVolume->GetNode(layerName);
+       if (layNode) {
+           TGeoHMatrix layMatrix(*layNode->GetMatrix());           
+           Double_t *trans  = layMatrix.GetTranslation();
+           Double_t *r      = layMatrix.GetRotationMatrix();
+           Double_t rot[10] = {r[0],r[1],r[2],
+                               r[3],r[4],r[5],
+                               r[6],r[7],r[8], 1.0};
+           Int_t iDet = 1;
+           Int_t iLad = 1;
+           Int_t iLay = 1;
+            DecodeDetector(mod,layNode->GetNumber(),i+1,0,0);
+            DecodeDetectorLayers(mod,iLay,iLad,iDet);
+           geom->CreateMatrix(startMod,iLay,iLad,iDet,kSPD,trans,rot);
+           startMod++;
+       };
+    };
+    
+    // SDD
+    for (Int_t i=0; i<2;i++) {
+       sprintf(layerName, "ITSsddWafer_%i",i+4+1);
+       TGeoNode *layNode = itsmotherVolume->GetNode(layerName);
+       if (layNode) {
+           TGeoHMatrix layMatrix(*layNode->GetMatrix());
+           Double_t *trans  = layMatrix.GetTranslation();
+           Double_t *r      = layMatrix.GetRotationMatrix();
+           Double_t rot[10] = {r[0],r[1],r[2],
+                               r[3],r[4],r[5],
+                               r[6],r[7],r[8], 1.0};
+           Int_t iDet = 1;
+           Int_t iLad = 1;
+           Int_t iLay = 1;
+            DecodeDetector(mod,layNode->GetNumber(),i+1,0,0);
+            DecodeDetectorLayers(mod,iLay,iLad,iDet);
+           geom->CreateMatrix(startMod,iLay,iLad,iDet,kSDD,trans,rot);
+           startMod++;
+       };
+    };
+    
+    // SSD
+    for (Int_t i=0; i<4;i++) {
+       sprintf(layerName, "ITSssdWafer_%i",i+4+2+1);
+       TGeoNode *layNode = itsmotherVolume->GetNode(layerName);
+       if (layNode) {
+           TGeoHMatrix layMatrix(*layNode->GetMatrix());           
+           Double_t *trans  = layMatrix.GetTranslation();
+           Double_t *r      = layMatrix.GetRotationMatrix();
+           Double_t rot[10] = {r[0],r[1],r[2],
+                               r[3],r[4],r[5],
+                               r[6],r[7],r[8], 1.0};
+           Int_t iDet = 1;
+           Int_t iLad = 1;
+           Int_t iLay = 5;
+            DecodeDetector(mod,layNode->GetNumber(),i+1,0,0);
+            DecodeDetectorLayers(mod,iLay,iLad,iDet);
+           geom->CreateMatrix(startMod,iLay,iLad,iDet,kSSD,trans,rot);
+           startMod++;
+       };
+    };
 
-  default: {
-    AliFatal("Undefined geometry");
+    return kTRUE;
+  */
     return kFALSE;
-  } break; // end case
-  } // end switch
-  return kFALSE;
 }
 //______________________________________________________________________
 Bool_t AliITSInitGeometry::InitAliITSgeomPPRasymmFMD(AliITSgeom *geom){
@@ -233,7 +730,7 @@ Bool_t AliITSInitGeometry::InitAliITSgeomPPRasymmFMD(AliITSgeom *geom){
     Double_t tran[3]={0.0,0.0,0.0},rot[10]={9*0.0,1.0};
     TArrayD shapePar;
     TString path,shapeName;
-    TGeoHMatrix materix;
+    TGeoHMatrix matrix;
     Bool_t initSeg[3]={kFALSE,kFALSE,kFALSE};
     TStopwatch *time = 0x0;if(fTiming) time=new TStopwatch();
 
@@ -247,15 +744,18 @@ Bool_t AliITSInitGeometry::InitAliITSgeomPPRasymmFMD(AliITSgeom *geom){
         path.Form(kNames[fMinorVersion-1][lay-1].Data(),
                   kPathbase.Data(),cpn0,cpn1,cpn2);
         geom->GetGeomMatrix(mod)->SetPath(path);
-        GetTransformation(path.Data(),materix);
-        geom->SetTrans(mod,materix.GetTranslation());
-        geom->SetRotMatrix(mod,materix.GetRotationMatrix());
+        GetTransformation(path.Data(),matrix);
+        geom->SetTrans(mod,matrix.GetTranslation());
+       TransposeTGeoHMatrix(&matrix); //Transpose TGeo's rotation matrixes
+        geom->SetRotMatrix(mod,matrix.GetRotationMatrix());
         if(initSeg[kIdet[lay-1]]) continue;
         GetShape(path,shapeName,shapePar);
         if(shapeName.CompareTo("BOX")){
-            Error("InitITSgeom","Geometry changed without proper code update"
-                  "or error in reading geometry. Shape is not BOX.");
-            return kFALSE;
+         Error("InitITSgeomPPRasymmFMD",
+               "Geometry changed without proper code update or error "
+               "in reading geometry. Shape is not BOX. Shape is %s",
+               shapeName.Data());
+         return kFALSE;
         } // end if
        InitGeomShapePPRasymmFMD(kIdet[lay-1],initSeg,shapePar,geom);
     } // end for module
@@ -266,7 +766,6 @@ Bool_t AliITSInitGeometry::InitAliITSgeomPPRasymmFMD(AliITSgeom *geom){
     } // end if
     return kTRUE;
 }
-
 //______________________________________________________________________
 Bool_t AliITSInitGeometry::InitAliITSgeomV11Hybrid(AliITSgeom *geom){
     // Initilizes the geometry transformation class AliITSgeom
@@ -319,10 +818,15 @@ Bool_t AliITSInitGeometry::InitAliITSgeomV11Hybrid(AliITSgeom *geom){
 
   for(mod=0;mod<nmods;mod++) {
 
+//     DecodeDetectorLayers(mod,lay,lad,det); // Write
+//     geom->CreateMatrix(mod,lay,lad,det,kIdet[lay-1],tran,rot);
+//     RecodeDetector(mod,cpn0,cpn1,cpn2); // Write reusing lay,lad,det.
     DecodeDetectorLayers(mod,lay,lad,det); // Write
     geom->CreateMatrix(mod,lay,lad,det,kIdet[lay-1],tran,rot);
     RecodeDetector(mod,cpn0,cpn1,cpn2); // Write reusing lay,lad,det.
 
+
+
     if (SDDIsTGeoNative())
       if (kIdet[lay-1]==kSDD) {
        cpn0 = lad-1;
@@ -335,6 +839,7 @@ Bool_t AliITSInitGeometry::InitAliITSgeomV11Hybrid(AliITSgeom *geom){
     geom->GetGeomMatrix(mod)->SetPath(path);
     GetTransformation(path.Data(),matrix);
     geom->SetTrans(mod,matrix.GetTranslation());
+    TransposeTGeoHMatrix(&matrix); //Transpose TGeo's rotation matrixes
     geom->SetRotMatrix(mod,matrix.GetRotationMatrix());
     if(initSeg[kIdet[lay-1]]) continue;
     GetShape(path,shapeName,shapePar);
@@ -353,7 +858,6 @@ Bool_t AliITSInitGeometry::InitAliITSgeomV11Hybrid(AliITSgeom *geom){
   } // end if
   return kTRUE;
 }
-
 //______________________________________________________________________
 Bool_t AliITSInitGeometry::InitAliITSgeomV11(AliITSgeom *geom){
   // Initilizes the geometry transformation class AliITSgeom
@@ -404,6 +908,7 @@ Bool_t AliITSInitGeometry::InitAliITSgeomV11(AliITSgeom *geom){
     geom->GetGeomMatrix(mod)->SetPath(path);
     if (GetTransformation(path.Data(),matrix)) {
       geom->SetTrans(mod,matrix.GetTranslation());
+      TransposeTGeoHMatrix(&matrix); //Transpose TGeo's rotation matrixes
       geom->SetRotMatrix(mod,matrix.GetRotationMatrix());
     }
     
@@ -630,7 +1135,7 @@ Bool_t AliITSInitGeometry::GetShape(const TString &volumePath,
        par.AddAt(box->GetDY(),1);
        par.AddAt(box->GetDZ(),2);
        return kTRUE;
-    }
+    } // end if
     if (classType==TGeoTrd1::Class()) {
        shapeType = "TRD1";
        npar = 4;
@@ -641,7 +1146,7 @@ Bool_t AliITSInitGeometry::GetShape(const TString &volumePath,
        par.AddAt(trd1->GetDy(), 2);
        par.AddAt(trd1->GetDz(), 3);
        return kTRUE;
-    }
+    } // end if
     if (classType==TGeoTrd2::Class()) {
        shapeType = "TRD2";
        npar = 5;
@@ -653,7 +1158,7 @@ Bool_t AliITSInitGeometry::GetShape(const TString &volumePath,
        par.AddAt(trd2->GetDy2(),3);
        par.AddAt(trd2->GetDz(), 4);
        return kTRUE;
-    }
+    } // end if
     if (classType==TGeoTrap::Class()) {
        shapeType = "TRAP";
        npar = 11;
@@ -672,7 +1177,7 @@ Bool_t AliITSInitGeometry::GetShape(const TString &volumePath,
        par.AddAt(trap->GetTl2(),9);
        par.AddAt(TMath::Tan(trap->GetAlpha2()*TMath::DegToRad()),10);
        return kTRUE;
-    }
+    } // end if
     if (classType==TGeoTube::Class()) {
        shapeType = "TUBE";
        npar = 3;
@@ -682,7 +1187,7 @@ Bool_t AliITSInitGeometry::GetShape(const TString &volumePath,
        par.AddAt(tube->GetRmax(),1);
        par.AddAt(tube->GetDz(),2);
        return kTRUE;
-    }
+    } // end if
     if (classType==TGeoTubeSeg::Class()) {
        shapeType = "TUBS";
        npar = 5;
@@ -694,7 +1199,7 @@ Bool_t AliITSInitGeometry::GetShape(const TString &volumePath,
        par.AddAt(tubs->GetPhi1(),3);
        par.AddAt(tubs->GetPhi2(),4);
        return kTRUE;
-    }
+    } // end if
     if (classType==TGeoCone::Class()) {
        shapeType = "CONE";
        npar = 5;
@@ -706,7 +1211,7 @@ Bool_t AliITSInitGeometry::GetShape(const TString &volumePath,
        par.AddAt(cone->GetRmin2(),3);
        par.AddAt(cone->GetRmax2(),4);
        return kTRUE;
-    }
+    } // end if
     if (classType==TGeoConeSeg::Class()) {
        shapeType = "CONS";
        npar = 7;
@@ -720,7 +1225,7 @@ Bool_t AliITSInitGeometry::GetShape(const TString &volumePath,
        par.AddAt(cons->GetPhi1(),5);
        par.AddAt(cons->GetPhi2(),6);
        return kTRUE;
-    }
+    } // end if
     if (classType==TGeoSphere::Class()) {
        shapeType = "SPHE";
        npar = 6;
@@ -734,7 +1239,7 @@ Bool_t AliITSInitGeometry::GetShape(const TString &volumePath,
        par.AddAt(sphe->GetPhi1(),4);
        par.AddAt(sphe->GetPhi2(),5);
        return kTRUE;
-    }
+    } // end if
     if (classType==TGeoPara::Class()) {
        shapeType = "PARA";
        npar = 6;
@@ -747,7 +1252,7 @@ Bool_t AliITSInitGeometry::GetShape(const TString &volumePath,
        par.AddAt(para->GetTxz(),4);
        par.AddAt(para->GetTyz(),5);
        return kTRUE;
-    }
+    } // end if
     if (classType==TGeoPgon::Class()) {
        shapeType = "PGON";
        TGeoPgon *pgon = (TGeoPgon*)shape;
@@ -767,7 +1272,7 @@ Bool_t AliITSInitGeometry::GetShape(const TString &volumePath,
            par.AddAt(rmax[i], 4+3*i+2);
        }
        return kTRUE;
-    }
+    } // end if
     if (classType==TGeoPcon::Class()) {
        shapeType = "PCON";
        TGeoPcon *pcon = (TGeoPcon*)shape;
@@ -787,7 +1292,7 @@ Bool_t AliITSInitGeometry::GetShape(const TString &volumePath,
            par.AddAt(rmax[i], 3+3*i+2);
        }
        return kTRUE;
-    }
+    } // end if
     if (classType==TGeoEltu::Class()) {
        shapeType = "ELTU";
        npar = 3;
@@ -797,7 +1302,7 @@ Bool_t AliITSInitGeometry::GetShape(const TString &volumePath,
        par.AddAt(eltu->GetB(),1);
        par.AddAt(eltu->GetDz(),2);
        return kTRUE;
-    }
+    } // end if
     if (classType==TGeoHype::Class()) {
        shapeType = "HYPE";
        npar = 5;
@@ -809,7 +1314,7 @@ Bool_t AliITSInitGeometry::GetShape(const TString &volumePath,
        par.AddAt(hype->GetStIn(),3);
        par.AddAt(hype->GetStOut(),4);
        return kTRUE;
-    }
+    } // end if
     if (classType==TGeoGtra::Class()) {
        shapeType = "GTRA";
        npar = 12;
@@ -829,7 +1334,7 @@ Bool_t AliITSInitGeometry::GetShape(const TString &volumePath,
        par.AddAt(TMath::Tan(trap->GetAlpha2()*TMath::DegToRad()),10);
        par.AddAt(trap->GetTwistAngle(),11);
        return kTRUE;
-    }
+    } // end if
     if (classType==TGeoCtub::Class()) {
        shapeType = "CTUB";
        npar = 11;
@@ -849,14 +1354,15 @@ Bool_t AliITSInitGeometry::GetShape(const TString &volumePath,
        par.AddAt(tx[1],9);
        par.AddAt(tx[2],10);
        return kTRUE;
-    }
+    } // end if
     Error("GetShape","Getting shape parameters for shape %s not implemented",
          shape->ClassName());
+    shapeType = "Unknown";
     return kFALSE;
 }
 //______________________________________________________________________
-void AliITSInitGeometry::DecodeDetector(Int_t &mod,Int_t layer,Int_t cpn0,
-                                        Int_t cpn1,Int_t cpn2) const {
+void AliITSInitGeometry::DecodeDetector(
+    Int_t &mod,Int_t layer,Int_t cpn0,Int_t cpn1,Int_t cpn2) const {
     // decode geometry into detector module number. There are two decoding
     // Scheams. Old which does not follow the ALICE coordinate system
     // requirements, and New which dose.
@@ -870,59 +1376,568 @@ void AliITSInitGeometry::DecodeDetector(Int_t &mod,Int_t layer,Int_t cpn0,
     //                   of copy numbers.
     // Return:
     //    none.
-    const Int_t kDetPerLadderSPD[2]={2,4};
-    const Int_t kDetPerLadder[6]={4,4,6,8,22,25};
-    const Int_t kLadPerLayer[6]={20,40,14,22,34,38};
-    Int_t lay=-1,lad=-1,det=-1,i;
 
-    if(fDecode){ // New decoding scheam
-        switch (layer){
-        case 1:{
-            lay = layer;
-            det = 5-cpn2;
-            if(cpn0==4&&cpn1==1) lad=1;
-            else if(cpn0==4&&cpn1==2) lad=20;
-            else if(cpn0<4){
-                lad = 8-cpn1-kDetPerLadderSPD[layer-1]*(cpn0-1);
-            }else{ // cpn0>4
-                lad = 28-cpn1-kDetPerLadderSPD[layer-1]*(cpn0-1);
-            } // end if
-        } break;
-        case 2:{
-            lay = layer;
-            det = 5-cpn2;
-            if(cpn0==4&&cpn1==1) lad=1;
-            else if(cpn0<4){
-                lad = 14-cpn1-kDetPerLadderSPD[layer-1]*(cpn0-1);
-            }else{ // cpn0>4
-                lad = 54-cpn1-kDetPerLadderSPD[layer-1]*(cpn0-1);
-            } // end if
-        } break;
-        case 3:{
-            lay = layer;
-            if(cpn0<5) lad = 5-cpn0;
-            else lad = 19-cpn0;
-            det = 7-cpn1;
-        } break;
-        case 4:{
-            lay = layer;
-            if(cpn0<7) lad = 7-cpn0;
-            else lad = 29-cpn0;
-            det = 9-cpn1;
-        } break;
-        case 5:{
-            lay = layer;
-            if(cpn0<10) lad = 10-cpn0;
-            else lad = 44-cpn0;
-            det = 23-cpn1;
-        } break;
-        case 6:{
-            lay = layer;
-            if(cpn0<9) lad = 9-cpn0;
-            else lad = 47-cpn0;
-            det = 26-cpn1;
-        } break;
-        } // end switch
+    // This is a FIXED switch yard function. I (Bjorn Nilsen) Don't 
+    // like them but I see not better way for the moment.
+    switch (fMajorVersion){
+    case kvtest:{
+        if(GetMinorVersion()==1)
+            return DecodeDetectorvPPRasymmFMD(mod,layer,cpn0,cpn1,cpn2);
+        else if(GetMinorVersion()==2)
+            return DecodeDetectorvtest2(mod,layer,cpn0,cpn1,cpn2);
+        Warning("DecodeDetector",
+                "Geometry is kvtest minor version=%d is not defined",
+                GetMinorVersion());
+    }break;
+    case kvDefault:{
+        Error("DecodeDetector","Major version = kvDefault, not supported");
+    }break;
+    case kvSPD02:{
+        return DecodeDetectorvSPD02(mod,layer,cpn0,cpn1,cpn2);
+    }break;
+    case kvSDD03:{
+        return DecodeDetectorvSDD03(mod,layer,cpn0,cpn1,cpn2);
+    }break;
+    case kvSSD03:{
+        return DecodeDetectorvSSD03(mod,layer,cpn0,cpn1,cpn2);
+    }break;
+    case kvITS04:{
+        return DecodeDetectorvITS04(mod,layer,cpn0,cpn1,cpn2);
+    }break;
+    case kvPPRcourseasymm:{
+        return DecodeDetectorvPPRcourseasymm(mod,layer,cpn0,cpn1,cpn2);
+    }break;
+    case kvPPRasymmFMD:{
+        return DecodeDetectorvPPRasymmFMD(mod,layer,cpn0,cpn1,cpn2);
+    }break;
+    case kv11:{
+        return DecodeDetectorv11(mod,layer,cpn0,cpn1,cpn2);
+    }break;
+    case kv11Hybrid:{
+        return DecodeDetectorv11Hybrid(mod,layer,cpn0,cpn1,cpn2);
+    }break;
+    default:{
+        Error("DecodeDetector","Major version = %d, not supported",
+              (Int_t)fMajorVersion);
+        return;
+    }break;
+    } // end switch
+    return;
+}
+//______________________________________________________________________
+void AliITSInitGeometry::RecodeDetector(Int_t mod,Int_t &cpn0,
+                                        Int_t &cpn1,Int_t &cpn2){
+    // decode geometry into detector module number. There are two decoding
+    // Scheams. Old which does not follow the ALICE coordinate system
+    // requirements, and New which dose.
+    // Inputs:
+    //    Int_t mod      The module number assoicated with this set
+    //                   of copy numbers.
+    // Output:
+    //    Int_t cpn0     The lowest copy number
+    //    Int_t cpn1     The middle copy number
+    //    Int_t cpn2     the highest copy number
+    // Return:
+    //    none.
+
+    // This is a FIXED switch yard function. I (Bjorn Nilsen) Don't 
+    // like them but I see not better way for the moment.
+    switch (fMajorVersion){
+    case kvtest:{
+        if(GetMinorVersion()==1) 
+            return RecodeDetectorvPPRasymmFMD(mod,cpn0,cpn1,cpn2);
+        else if(GetMinorVersion()==2)
+            return RecodeDetectorvtest2(mod,cpn0,cpn1,cpn2);
+        Warning("RecodeDetector",
+                "Geometry is kvtest minor version=%d is not defined",
+                GetMinorVersion());
+        return;
+    }break;
+    case kvDefault:{
+        Error("RecodeDetector","Major version = kvDefault, not supported");
+        return;
+    }break;
+    case kvSPD02:{
+        return RecodeDetectorvSPD02(mod,cpn0,cpn1,cpn2);
+    }break;
+    case kvSDD03:{
+        return RecodeDetectorvSDD03(mod,cpn0,cpn1,cpn2);
+    }break;
+    case kvSSD03:{
+        return RecodeDetectorvSSD03(mod,cpn0,cpn1,cpn2);
+    }break;
+    case kvITS04:{
+        return RecodeDetectorvITS04(mod,cpn0,cpn1,cpn2);
+    }break;
+    case kvPPRcourseasymm:{
+        return RecodeDetectorvPPRcourseasymm(mod,cpn0,cpn1,cpn2);
+    }break;
+    case kvPPRasymmFMD:{
+        return RecodeDetectorvPPRasymmFMD(mod,cpn0,cpn1,cpn2);
+    }break;
+    case kv11:{
+        return RecodeDetectorv11(mod,cpn0,cpn1,cpn2);
+    }break;
+    case kv11Hybrid:{
+        return RecodeDetectorv11Hybrid(mod,cpn0,cpn1,cpn2);
+    }break;
+    default:{
+        Error("RecodeDetector","Major version = %d, not supported",
+              (Int_t)fMajorVersion);
+        return;
+    }break;
+    } // end switch
+    return;
+}
+//______________________________________________________________________
+void AliITSInitGeometry::DecodeDetectorLayers(Int_t mod,Int_t &layer,
+                                              Int_t &lad,Int_t &det){
+    // decode geometry into detector module number. There are two decoding
+    // Scheams. Old which does not follow the ALICE coordinate system
+    // requirements, and New which dose. Note, this use of layer ladder
+    // and detector numbers are strictly for internal use of this
+    // specific code. They do not represent the "standard" layer ladder
+    // or detector numbering except in a very old and obsoleate sence.
+    // Inputs:
+    //    Int_t mod      The module number assoicated with this set
+    //                   of copy numbers.
+    // Output:
+    //    Int_t lay     The layer number
+    //    Int_t lad     The ladder number
+    //    Int_t det     the dettector number
+    // Return:
+    //    none.
+
+    // This is a FIXED switch yard function. I (Bjorn Nilsen) Don't 
+    // like them but I see not better way for the moment.
+    switch (fMajorVersion){
+    case kvtest:{
+        if(GetMinorVersion()==1) 
+            return DecodeDetectorLayersvPPRasymmFMD(mod,layer,lad,det);
+        else if(GetMinorVersion()==2)
+            return DecodeDetectorLayersvtest2(mod,layer,lad,det);
+        Warning("DecodeDetectorLayers",
+                "Geometry is kvtest minor version=%d is not defined",
+                GetMinorVersion());
+        return;
+    }break;
+    case kvDefault:{
+        Error("DecodeDetectorLayers",
+              "Major version = kvDefault, not supported");
+        return;
+    }break;
+    case kvSPD02:{
+        return DecodeDetectorLayersvSPD02(mod,layer,lad,det);
+    }break;
+    case kvSDD03:{
+        return DecodeDetectorLayersvSDD03(mod,layer,lad,det);
+    }break;
+    case kvSSD03:{
+        return DecodeDetectorLayersvSSD03(mod,layer,lad,det);
+    }break;
+    case kvITS04:{
+        return DecodeDetectorLayersvITS04(mod,layer,lad,det);
+    }break;
+    case kvPPRcourseasymm:{
+        return DecodeDetectorLayersvPPRcourseasymm(mod,layer,lad,det);
+    }break;
+    case kvPPRasymmFMD:{
+        return DecodeDetectorLayersvPPRasymmFMD(mod,layer,lad,det);
+    }break;
+    case kv11:{
+        return DecodeDetectorLayersv11(mod,layer,lad,det);
+    }break;
+    case kv11Hybrid:{
+        return DecodeDetectorLayersv11Hybrid(mod,layer,lad,det);
+    }break;
+    default:{
+        Error("DecodeDetectorLayers","Major version = %d, not supported",
+              (Int_t)fMajorVersion);
+        return;
+    }break;
+    } // end switch
+    return;
+}
+//______________________________________________________________________
+void AliITSInitGeometry::DecodeDetectorvSPD02(
+    Int_t &mod,Int_t ncpn,Int_t cpy0,Int_t cpy1,Int_t cpy2) const {
+    // decode geometry into detector module number
+    // Inputs:
+    //    Int_t ncpn     The Number of copies of this volume
+    //    Int_t cpy0     The lowest copy number
+    //    Int_t cpy1     The middle copy number
+    //    Int_t cpy2     the highest copy number
+    // Output:
+    //    Int_t &mod     The module number assoicated with this set
+    //                   of copy numbers.
+    // Return:
+    //    none.
+
+    // detector = ladder = 1
+    if(ncpn==4 && cpy1>2) mod = cpy1; // layer = 1,2
+    else mod = cpy1-1; // layer = 4,5
+    if(ncpn==1) mod = 2; // layer=3
+    cpy0 = cpy2;
+    return;
+}
+//______________________________________________________________________
+void AliITSInitGeometry::RecodeDetectorvSPD02(Int_t mod,Int_t &cpn0,
+                                        Int_t &cpn1,Int_t &cpn2){
+    // decode geometry into detector module number. There are two decoding
+    // Scheams. Old which does not follow the ALICE coordinate system
+    // requirements, and New which dose.
+    // Inputs:
+    //    Int_t mod      The module number assoicated with this set
+    //                   of copy numbers.
+    // Output:
+    //    Int_t cpn0     The lowest copy number
+    //    Int_t cpn1     The middle copy number
+    //    Int_t cpn2     the highest copy number
+    // Return:
+    //    none.
+
+    cpn2 = 0;
+    if(mod==2){
+        cpn0 = 1;
+        cpn1 = 1;
+        return;
+    } else if(mod<2){
+        cpn0 = 1;
+        cpn1 = mod+1;
+    }else{
+        cpn0 = 1;
+        cpn1 = mod;
+    } // end if
+    return;
+}
+//______________________________________________________________________
+void AliITSInitGeometry::DecodeDetectorLayersvSPD02(Int_t mod,Int_t &lay,
+                                                    Int_t &lad,Int_t &det){
+    // decode geometry into detector module number. There are two decoding
+    // Scheams. Old which does not follow the ALICE coordinate system
+    // requirements, and New which dose. Note, this use of layer ladder
+    // and detector numbers are strictly for internal use of this
+    // specific code. They do not represent the "standard" layer ladder
+    // or detector numbering except in a very old and obsoleate sence.
+    // Inputs:
+    //    Int_t mod      The module number assoicated with this set
+    //                   of copy numbers.
+    // Output:
+    //    Int_t lay     The layer number
+    //    Int_t lad     The ladder number
+    //    Int_t det     the dettector number
+    // Return:
+    //    none.
+
+    lay = mod+1;
+    lad = det = 1;
+    return;
+}
+//______________________________________________________________________
+void AliITSInitGeometry::DecodeDetectorvSDD03(
+    Int_t &mod,Int_t ncpys,Int_t cpy0,Int_t cpy1,Int_t cpy2) const {
+    // decode geometry into detector module number. There are two decoding
+    // Scheams. Old which does not follow the ALICE coordinate system
+    // requirements, and New which dose.
+    // Inputs:
+    //    Int_t ncpys    The number of posible copies cpn1
+    //    Int_t cpy0     The lowest copy number
+    //    Int_t cpy1     The middle copy number
+    //    Int_t cpy2     the highest copy number
+    // Output:
+    //    Int_t &mod     The module number assoicated with this set
+    //                   of copy numbers.
+    // Return:
+    //    none.
+
+    if(ncpys==10){ // ITEL detectors
+        if(cpy1>4) mod = cpy1+1;
+        else mod = cpy1-1;
+    }else{ // IDET detectors
+        if(cpy1==1) mod = 4;
+        else mod = 5;
+    } // end if
+    cpy0=cpy2;
+    return;
+}
+//______________________________________________________________________
+void AliITSInitGeometry::RecodeDetectorvSDD03(Int_t mod,Int_t &cpn0,
+                                        Int_t &cpn1,Int_t &cpn2){
+    // decode geometry into detector module number. There are two decoding
+    // Scheams. Old which does not follow the ALICE coordinate system
+    // requirements, and New which dose.
+    // Inputs:
+    //    Int_t mod      The module number assoicated with this set
+    //                   of copy numbers.
+    // Output:
+    //    Int_t cpn0     The lowest copy number
+    //    Int_t cpn1     The middle copy number
+    //    Int_t cpn2     the highest copy number
+    // Return:
+    //    none.
+
+    cpn0 = 1;
+    cpn2 = 0;
+    if(mod<4) cpn1 = mod+1;
+    else if(mod==4||mod==5) cpn1 = mod-3;
+    else cpn1 = mod-1;
+    return;
+}
+//______________________________________________________________________
+void AliITSInitGeometry::DecodeDetectorLayersvSDD03(Int_t mod,Int_t &lay,
+                                                    Int_t &lad,Int_t &det){
+    // decode geometry into detector module number. There are two decoding
+    // Scheams. Old which does not follow the ALICE coordinate system
+    // requirements, and New which dose. Note, this use of layer ladder
+    // and detector numbers are strictly for internal use of this
+    // specific code. They do not represent the "standard" layer ladder
+    // or detector numbering except in a very old and obsoleate sence.
+    // Inputs:
+    //    Int_t mod      The module number assoicated with this set
+    //                   of copy numbers.
+    // Output:
+    //    Int_t lay     The layer number
+    //    Int_t lad     The ladder number
+    //    Int_t det     the dettector number
+    // Return:
+    //    none.
+
+    lad = det = 1;
+    lay = mod+1;
+    return;
+}
+//______________________________________________________________________
+void AliITSInitGeometry::DecodeDetectorvSSD03(
+    Int_t &mod,Int_t dtype,Int_t cpn0,Int_t cpn1,Int_t cpn2) const {
+    // decode geometry into detector module number. There are two decoding
+    // Scheams. Old which does not follow the ALICE coordinate system
+    // requirements, and New which dose.
+    // Inputs:
+    //    Int_t dtype    The detector type 1=ITSA 2=IGAR 3=IFRA
+    //    Int_t cpn0     The lowest copy number
+    //    Int_t cpn1     The middle copy number
+    //    Int_t cpn2     the highest copy number
+    // Output:
+    //    Int_t &mod     The module number assoicated with this set
+    //                   of copy numbers.
+    // Return:
+    //    none.
+
+    if(dtype==2){mod=2; return;}
+    if(dtype==3){mod=3; return;}
+    mod = cpn0-1;
+    if(cpn0==3) mod = 4;
+    cpn1=cpn2;
+    return;
+}
+//______________________________________________________________________
+void AliITSInitGeometry::RecodeDetectorvSSD03(Int_t mod,Int_t &cpn0,
+                                        Int_t &cpn1,Int_t &cpn2){
+    // decode geometry into detector module number. There are two decoding
+    // Scheams. Old which does not follow the ALICE coordinate system
+    // requirements, and New which dose.
+    // Inputs:
+    //    Int_t mod      The module number assoicated with this set
+    //                   of copy numbers.
+    // Output:
+    //    Int_t cpn0     The lowest copy number
+    //    Int_t cpn1     The middle copy number
+    //    Int_t cpn2     the highest copy number
+    // Return:
+    //    none.
+
+    cpn1=1;
+    cpn2=0;
+    if(mod<2) cpn0=mod+1;
+    else if (mod==2||mod==3) cpn0=1;
+    else cpn0 = 3;
+    return;
+}
+//______________________________________________________________________
+void AliITSInitGeometry::DecodeDetectorLayersvSSD03(Int_t mod,Int_t &lay,
+                                                    Int_t &lad,Int_t &det){
+    // decode geometry into detector module number. There are two decoding
+    // Scheams. Old which does not follow the ALICE coordinate system
+    // requirements, and New which dose. Note, this use of layer ladder
+    // and detector numbers are strictly for internal use of this
+    // specific code. They do not represent the "standard" layer ladder
+    // or detector numbering except in a very old and obsoleate sence.
+    // Inputs:
+    //    Int_t mod      The module number assoicated with this set
+    //                   of copy numbers.
+    // Output:
+    //    Int_t lay     The layer number
+    //    Int_t lad     The ladder number
+    //    Int_t det     the dettector number
+    // Return:
+    //    none.
+
+    lad = det = 1;
+    lay = mod+1;
+    return;
+}
+//______________________________________________________________________
+void AliITSInitGeometry::DecodeDetectorvITS04(
+    Int_t &mod,Int_t dtype,Int_t cpn0,Int_t cpn1,Int_t cpn2) const {
+    // decode geometry into detector module number. There are two decoding
+    // Scheams. Old which does not follow the ALICE coordinate system
+    // requirements, and New which dose.
+    // Inputs:
+    //    Int_t dtype    The detector type 1=ITSA 2=IGAR 3=IFRA
+    //    Int_t cpn0     The lowest copy number
+    //    Int_t cpn1     The middle copy number
+    //    Int_t cpn2     the highest copy number
+    // Output:
+    //    Int_t &mod     The module number assoicated with this set
+    //                   of copy numbers.
+    // Return:
+    //    none.
+
+    mod = dtype-1;
+    cpn0 = cpn1 = cpn2;
+    return;
+}
+//______________________________________________________________________
+void AliITSInitGeometry::RecodeDetectorvITS04(Int_t mod,Int_t &cpn0,
+                                        Int_t &cpn1,Int_t &cpn2){
+    // decode geometry into detector module number. There are two decoding
+    // Scheams. Old which does not follow the ALICE coordinate system
+    // requirements, and New which dose.
+    // Inputs:
+    //    Int_t mod      The module number assoicated with this set
+    //                   of copy numbers.
+    // Output:
+    //    Int_t cpn0     The lowest copy number
+    //    Int_t cpn1     The middle copy number
+    //    Int_t cpn2     the highest copy number
+    // Return:
+    //    none.
+
+    cpn1 = cpn2 = 0;
+    switch(mod){
+    case 0:case 1:case 2:case 3:{
+        cpn0 = mod+1;
+    }break;
+    case 4: case 5:{
+        cpn0 = mod-3;
+    }break;
+    case 6:case 7:case 8:case 9:{
+        cpn0 = mod-5;
+    } break;
+    default:
+        cpn0 = 0;
+        break;
+    }// end switch
+    return;
+}
+//______________________________________________________________________
+void AliITSInitGeometry::DecodeDetectorLayersvITS04(Int_t mod,Int_t &lay,
+                                                    Int_t &lad,Int_t &det){
+    // decode geometry into detector module number. There are two decoding
+    // Scheams. Old which does not follow the ALICE coordinate system
+    // requirements, and New which dose. Note, this use of layer ladder
+    // and detector numbers are strictly for internal use of this
+    // specific code. They do not represent the "standard" layer ladder
+    // or detector numbering except in a very old and obsoleate sence.
+    // Inputs:
+    //    Int_t mod      The module number assoicated with this set
+    //                   of copy numbers.
+    // Output:
+    //    Int_t lay     The layer number
+    //    Int_t lad     The ladder number
+    //    Int_t det     the dettector number
+    // Return:
+    //    none.
+
+    lad = 1;
+    switch(mod){
+    case 0:case 1:case 2:case 3:{
+        lay = mod/2 +1;
+        det = mod%2 +1;
+    }break;
+    case 4: case 5:{
+        lay = mod -1;
+    }break;
+    case 6:case 7:case 8:case 9:{
+        lay = mod/2 +2;
+        det = mod%2 +1;
+    }break;
+    default:
+        lay = 0;
+        det = 0;
+        break;
+    } // end switch
+    return;
+}
+//______________________________________________________________________
+void AliITSInitGeometry::DecodeDetectorvPPRasymmFMD(Int_t &mod,Int_t layer,Int_t cpn0,
+                                        Int_t cpn1,Int_t cpn2) const {
+    // decode geometry into detector module number. There are two decoding
+    // Scheams. Old which does not follow the ALICE coordinate system
+    // requirements, and New which dose.
+    // Inputs:
+    //    Int_t layer    The ITS layer
+    //    Int_t cpn0     The lowest copy number
+    //    Int_t cpn1     The middle copy number
+    //    Int_t cpn2     the highest copy number
+    // Output:
+    //    Int_t &mod     The module number assoicated with this set
+    //                   of copy numbers.
+    // Return:
+    //    none.
+    const Int_t kDetPerLadderSPD[2]={2,4};
+    const Int_t kDetPerLadder[6]={4,4,6,8,22,25};
+    const Int_t kLadPerLayer[6]={20,40,14,22,34,38};
+    Int_t lay=-1,lad=-1,det=-1,i;
+
+    if(fDecode){ // New decoding scheam
+        switch (layer){
+        case 1:{
+            lay = layer;
+            det = 5-cpn2;
+            if(cpn0==4&&cpn1==1) lad=1;
+            else if(cpn0==4&&cpn1==2) lad=20;
+            else if(cpn0<4){
+                lad = 8-cpn1-kDetPerLadderSPD[layer-1]*(cpn0-1);
+            }else{ // cpn0>4
+                lad = 28-cpn1-kDetPerLadderSPD[layer-1]*(cpn0-1);
+            } // end if
+        } break;
+        case 2:{
+            lay = layer;
+            det = 5-cpn2;
+            if(cpn0==4&&cpn1==1) lad=1;
+            else if(cpn0<4){
+                lad = 14-cpn1-kDetPerLadderSPD[layer-1]*(cpn0-1);
+            }else{ // cpn0>4
+                lad = 54-cpn1-kDetPerLadderSPD[layer-1]*(cpn0-1);
+            } // end if
+        } break;
+        case 3:{
+            lay = layer;
+            if(cpn0<5) lad = 5-cpn0;
+            else lad = 19-cpn0;
+            det = 7-cpn1;
+        } break;
+        case 4:{
+            lay = layer;
+            if(cpn0<7) lad = 7-cpn0;
+            else lad = 29-cpn0;
+            det = 9-cpn1;
+        } break;
+        case 5:{
+            lay = layer;
+            if(cpn0<10) lad = 10-cpn0;
+            else lad = 44-cpn0;
+            det = 23-cpn1;
+        } break;
+        case 6:{
+            lay = layer;
+            if(cpn0<9) lad = 9-cpn0;
+            else lad = 47-cpn0;
+            det = 26-cpn1;
+        } break;
+        } // end switch
         mod = 0;
         for(i=0;i<layer-1;i++) mod += kLadPerLayer[i]*kDetPerLadder[i];
         mod += kDetPerLadder[layer-1]*(lad-1)+det-1;// module start at zero.
@@ -954,7 +1969,7 @@ void AliITSInitGeometry::DecodeDetector(Int_t &mod,Int_t layer,Int_t cpn0,
     return;
 }
 //______________________________________________________________________
-void AliITSInitGeometry::RecodeDetector(Int_t mod,Int_t &cpn0,
+void AliITSInitGeometry::RecodeDetectorvPPRasymmFMD(Int_t mod,Int_t &cpn0,
                                         Int_t &cpn1,Int_t &cpn2){
     // decode geometry into detector module number. There are two decoding
     // Scheams. Old which does not follow the ALICE coordinate system
@@ -1061,7 +2076,7 @@ void AliITSInitGeometry::RecodeDetector(Int_t mod,Int_t &cpn0,
     return;
 }
 //______________________________________________________________________
-void AliITSInitGeometry::DecodeDetectorLayers(Int_t mod,Int_t &lay,
+void AliITSInitGeometry::DecodeDetectorLayersvPPRasymmFMD(Int_t mod,Int_t &lay,
                                               Int_t &lad,Int_t &det){
     // decode geometry into detector module number. There are two decoding
     // Scheams. Old which does not follow the ALICE coordinate system
@@ -1097,7 +2112,147 @@ void AliITSInitGeometry::DecodeDetectorLayers(Int_t mod,Int_t &lay,
         lad++;
         mod2 += kDetPerLadder[lay-1];
     }while(mod2<=mod); // end while
-    if(lad>kLadPerLayer[lay-1]||lad<1) Error("DecodeDetectorLayera",
+    if(lad>kLadPerLayer[lay-1]||lad<1) Error("DecodeDetectorLayers",
+            "lad=%d>kLadPerLayer[lay-1=%d]=%d mod=%d mod2=%d",lad,lay-1,
+                                            kLadPerLayer[lay-1],mod,mod2);
+    mod2 -= kDetPerLadder[lay-1];
+    det = mod-mod2+1;
+    if(det>kDetPerLadder[lay-1]||det<1) Error("DecodeDetectorLayers",
+           "det=%d>detPerLayer[lay-1=%d]=%d mod=%d mod2=%d lad=%d",det,
+                                  lay-1,kDetPerLadder[lay-1],mod,mod2,lad);
+    return;
+}
+//______________________________________________________________________
+void AliITSInitGeometry::DecodeDetectorv11Hybrid(Int_t &mod,Int_t layer,Int_t cpn0,
+                                        Int_t cpn1,Int_t cpn2) const {
+    // decode geometry into detector module number
+    // Inputs:
+    //    Int_t layer    The ITS layer
+    //    Int_t cpn0     The lowest copy number
+    //    Int_t cpn1     The middle copy number
+    //    Int_t cpn2     the highest copy number
+    // Output:
+    //    Int_t &mod     The module number assoicated with this set
+    //                   of copy numbers.
+    // Return:
+    //    none.
+    const Int_t kDetPerLadderSPD[2]={2,4};
+    const Int_t kDetPerLadder[6]={4,4,6,8,22,25};
+    const Int_t kLadPerLayer[6]={20,40,14,22,34,38};
+    Int_t lay=-1,lad=-1,det=-1,i;
+
+    switch(layer){
+    case 1: case 2:{
+        lay = layer;
+        lad = cpn1+kDetPerLadderSPD[layer-1]*(cpn0-1);
+        det = cpn2;
+        }break;
+    case 3: case 4:{
+        lay = layer;
+        lad = cpn0;
+        det = cpn1;
+        }break;
+    case 5: case 6:{
+        lay = layer;
+        lad = cpn0;
+        det = cpn1;
+        }break;
+    default:{
+        }break;
+    } // end switch
+    mod = 0;
+    for(i=0;i<layer-1;i++) mod += kLadPerLayer[i]*kDetPerLadder[i];
+    mod += kDetPerLadder[layer-1]*(lad-1)+det-1;// module start at zero.
+    return;
+}
+//______________________________________________________________________
+void AliITSInitGeometry::RecodeDetectorv11Hybrid(Int_t mod,Int_t &cpn0,
+                                        Int_t &cpn1,Int_t &cpn2) {
+    // decode geometry into detector module number. There are two decoding
+    // Scheams. Old which does not follow the ALICE coordinate system
+    // requirements, and New which dose.
+    // Inputs:
+    //    Int_t mod      The module number assoicated with this set
+    //                   of copy numbers.
+    // Output:
+    //    Int_t cpn0     The lowest copy number
+    //    Int_t cpn1     The middle copy number
+    //    Int_t cpn2     the highest copy number
+    // Return:
+    //    none.
+    const Int_t kITSgeoTreeCopys[6][3]= {{10, 2, 4},// lay=1
+                                         {10, 4, 4},// lay=2
+                                         {14, 6, 1},// lay=3
+                                         {22, 8, 1},// lay=4
+                                         {34,22, 1},// lay=5
+                                         {38,25, 1}};//lay=6
+    const Int_t kDetPerLadderSPD[2]={2,4};
+    //    const Int_t kDetPerLadder[6]={4,4,6,8,22,25};
+    //    const Int_t kLadPerLayer[6]={20,40,14,22,34,38};
+    Int_t lay,lad,det;
+
+    cpn0 = cpn1 = cpn2 = 0;
+    DecodeDetectorLayers(mod,lay,lad,det);
+    // Old encoding
+    switch (lay){
+    case 1: case 2:{
+        cpn2 = det;     // Detector 1-4
+        cpn0 = (lad+kDetPerLadderSPD[lay-1]-1)/kDetPerLadderSPD[lay-1];
+        cpn1 = (lad+kDetPerLadderSPD[lay-1]-1)%kDetPerLadderSPD[lay-1] + 1;
+    } break;
+    case 3: case 4: case 5 : case 6:{
+        cpn2 = 1;
+        cpn1 = det;
+        cpn0 = lad;
+    } break;
+    default:{
+        Error("RecodeDetector","Old: mod=%d lay=%d not 1-6.");
+        return;
+    } break;
+    } // end switch
+    if(cpn0<1||cpn1<1||cpn2<1||
+       cpn0>kITSgeoTreeCopys[lay-1][0]||
+       cpn1>kITSgeoTreeCopys[lay-1][1]||
+       cpn2>kITSgeoTreeCopys[lay-1][2])
+        Error("RecodeDetector",
+              "cpn0=%d cpn1=%d cpn2=%d mod=%d lay=%d lad=%d det=%d",
+              cpn0,cpn1,cpn2,mod,lay,lad,det);
+    return;
+}
+//______________________________________________________________________
+void AliITSInitGeometry::DecodeDetectorLayersv11Hybrid(Int_t mod,Int_t &lay,
+                                              Int_t &lad,Int_t &det) {
+
+    // decode geometry into detector module number for v11Hybrid
+    // Inputs:
+    //    Int_t mod      The module number assoicated with this set
+    //                   of copy numbers.
+    // Output:
+    //    Int_t lay     The layer number
+    //    Int_t lad     The ladder number
+    //    Int_t det     the dettector number
+    // Return:
+    //    none.
+
+    const Int_t kDetPerLadder[6]={4,4,6,8,22,25};
+    const Int_t kLadPerLayer[6]={20,40,14,22,34,38};
+    Int_t mod2;
+
+    det  = 0;
+    lad  = 0;
+    lay  = 0;
+    mod2 = 0;
+    do{
+        mod2 += kLadPerLayer[lay]*kDetPerLadder[lay];
+        lay++;
+    } while(mod2<=mod); // end while
+    if(lay>6||lay<1) Error("DecodeDetectorLayers","0<lay=%d>6",lay);
+    mod2 -= kLadPerLayer[lay-1]*kDetPerLadder[lay-1];
+    do{
+        lad++;
+        mod2 += kDetPerLadder[lay-1];
+    } while(mod2<=mod); // end while
+    if(lad>kLadPerLayer[lay-1]||lad<1) Error("DecodeDetectorLayers",
             "lad=%d>kLadPerLayer[lay-1=%d]=%d mod=%d mod2=%d",lad,lay-1,
                                             kLadPerLayer[lay-1],mod,mod2);
     mod2 -= kDetPerLadder[lay-1];
@@ -1108,3 +2263,132 @@ void AliITSInitGeometry::DecodeDetectorLayers(Int_t mod,Int_t &lay,
     return;
 }
 
+//______________________________________________________________________
+Bool_t AliITSInitGeometry::WriteVersionString(Char_t *str,Int_t length,
+                        AliITSVersion_t maj,Int_t min,
+                        const Char_t *cvsDate,const Char_t *cvsRevision)const{
+    // fills the string str with the major and minor version number
+    // Inputs:
+    //   Char_t *str          The character string to hold the major 
+    //                        and minor version numbers in
+    //   Int_t  length        The maximum number of characters which 
+    //                        can be accomidated by this string. 
+    //                        str[length-1] must exist and will be set to zero
+    //   AliITSVersion_t maj  The major number
+    //   Int_t           min  The minor number
+    //   Char_t *cvsDate      The date string from cvs
+    //   Char_t *cvsRevision  The Revision string from cvs
+    // Outputs:
+    //   Char_t *str          The character string holding the major and minor
+    //                        version numbers. str[length-1] must exist
+    //                        and will be set to zero
+    // Return:
+    //   kTRUE if no errors
+    Int_t i,n,cvsDateLength,cvsRevisionLength;
+
+    cvsDateLength = (Int_t)strlen(cvsDate);
+    cvsRevisionLength = (Int_t)strlen(cvsRevision);
+    i = (Int_t)maj;
+    n = 50+(Int_t)(TMath::Log10(TMath::Abs((Double_t)i)))+1+
+        (Int_t)(TMath::Log10(TMath::Abs((Double_t)min)))+1
+        +cvsDateLength-6+cvsRevisionLength-10;
+    if(GetDebug()>1) printf("AliITSInitGeometry::WriteVersionString:"
+                        "length=%d major=%d minor=%d cvsDate=%s[%d] "
+                        "cvsRevision=%s[%d] n=%d\n",length,i,min,cvsDate,
+                        cvsDateLength,cvsRevision,cvsRevisionLength,n);
+    if(i<0) n++;
+    if(min<0) n++;
+    if(length<n){// not enough space to write in output string.
+        Warning("WriteVersionString","Output string not long enough "
+                "lenght=%d must be at least %d long\n",length,n);
+        return kFALSE;
+    } // end if length<n
+    char *cvsrevision = new char[cvsRevisionLength-10];
+    char *cvsdate = new char[cvsDateLength-6];
+    for(i=0;i<cvsRevisionLength-10;i++)
+        if(10+i<cvsRevisionLength-1)
+            cvsrevision[i] = cvsRevision[10+i]; else cvsrevision[i] = 0;
+    for(i=0;i<cvsDateLength-6;i++) if(6+i<cvsDateLength-1)
+        cvsdate[i] = cvsDate[6+i]; else cvsdate[i] = 0;
+    for(i=0;i<length;i++) str[i] = 0; // zero it out for now.
+    i = (Int_t)maj;
+    sprintf(str,"Major Version= %d Minor Version= %d Revision: %s Date: %s",
+            i,min,cvsrevision,cvsdate);
+    if(GetDebug()>1)printf("AliITSInitGeometry::WriteVersionString: "
+                       "n=%d str=%s revision[%zu] date[%zu]\n",
+                       n,str,strlen(cvsrevision),strlen(cvsdate));
+    delete[] cvsrevision;
+    delete[] cvsdate;
+    return kTRUE;
+}
+//______________________________________________________________________
+Bool_t AliITSInitGeometry::ReadVersionString(const Char_t *str,Int_t length,
+                                             AliITSVersion_t &maj,Int_t &min,
+                                             TDatime &dt)const{
+    // fills the string str with the major and minor version number
+    // Inputs:
+    //   Char_t *str   The character string to holding the major and minor
+    //                 version numbers in
+    //   Int_t  length The maximum number of characters which can be
+    //                 accomidated by this string. str[length-1] must exist
+    // Outputs:
+    //   Char_t *str   The character string holding the major and minor
+    //                 version numbers unchanged. str[length-1] must exist.
+    //   AliITSVersion_t maj  The major number
+    //   Int_t           min  The minor number
+    //   TDatime         dt   The date and time of the cvs commit
+    // Return:
+    //   kTRUE if no errors
+    Bool_t ok;
+    Char_t cvsRevision[10],cvsDate[11],cvsTime[9];
+    Int_t i,m,n=strlen(str),year,month,day,hours,minuits,seconds;
+
+    if(GetDebug()>1)printf("AliITSInitGeometry::ReadVersionString:"
+                       "str=%s length=%d\n",
+                       str,length);
+    if(n<35) return kFALSE; // not enough space for numbers
+    m = sscanf(str,"Major Version= %d  Minor Version= %d Revision: %s "
+               "Date: %s %s",&i,&min,cvsRevision,cvsDate,cvsTime);
+    ok = m==5;
+    if(!ok) return !ok;
+    m = sscanf(cvsDate,"%d/%d/%d",&year,&month,&day);
+    ok = m==3;
+    if(!ok) return !ok;
+    m = sscanf(cvsTime,"%d:%d:%d",&hours,&minuits,&seconds);
+    ok = m==3;
+    if(!ok) return !ok;
+    dt.Set(year,month,day,hours,minuits,seconds);
+    if(GetDebug()>1)printf("AliITSInitGeometry::ReadVersionString: i=%d min=%d "
+                       "cvsRevision=%s cvsDate=%s cvsTime=%s m=%d\n",
+                       i,min,cvsRevision,cvsDate,cvsTime,m);
+    if(GetDebug()>1)printf("AliITSInitGeometry::ReadVersionString: year=%d"
+                       " month=%d day=%d hours=%d minuits=%d seconds=%d\n",
+                       year,month,day,hours,minuits,seconds);
+    switch (i){
+    case kvITS04:{
+        maj = kvITS04;
+    } break;
+    case kvSPD02:{
+        maj = kvSPD02;
+    } break;
+    case kvSDD03:{
+        maj = kvSDD03;
+    } break;
+    case kvSSD03:{
+        maj = kvSSD03;
+    } break;
+    case kvPPRasymmFMD:{
+        maj = kvPPRasymmFMD;
+    } break;
+    case kv11:{
+        maj = kv11;
+    } break;
+    case kv11Hybrid:{
+        maj = kv11Hybrid;
+    } break;
+    default:{
+        maj = kvDefault;
+    } break;
+    } // end switch
+    return ok;
+}
index 8c4ea57ee02bee84a3558f6c97cfca718b882ac7..ec4a419f85c729aa9059405127d386396cdc1276 100644 (file)
@@ -14,25 +14,35 @@ $Id$
 
 #include <TObject.h>
 #include <TString.h>
+#include "AliITSgeom.h"
 
 typedef enum {
-  kvPPRasymmFMD=10,kv11=11,kv11Hybrid=110,kvDefault=1
+    kvtest=-1,kvDefault=0,
+    kvSPD02=1,kvSDD03=2,kvSSD03=3,kvITS04=4,
+    kvPPRcourseasymm=6,kvPPRasymmFMD=10,
+    kv11=11,kv11Hybrid=110
 } AliITSVersion_t;
 
-
-class AliITSgeom;
 class TArrayD;
 class TGeoHMatrix;
+class TDatime;
 
 class AliITSInitGeometry : public TObject{
  public:
-    AliITSInitGeometry(AliITSVersion_t 
-       version=kvPPRasymmFMD,Int_t minorversion=2);//Standard Constructor
+
+    AliITSInitGeometry();//Default Constructor
+    AliITSInitGeometry(AliITSVersion_t version,
+                      Int_t minorversion=2);//Standard Constructor
     //virtual ~AliITSInitGeometry(); // Destructor
     //
-    AliITSgeom* CreateAliITSgeom(); // Create and intilize geometry from TGeom
-    Bool_t InitAliITSgeom(AliITSgeom *geom);//Initilize goemetry from gGeoManager
+    // Create and initialize geometry from TGeo
+    AliITSgeom* CreateAliITSgeom();
+    AliITSgeom* CreateAliITSgeom(Int_t major,Int_t minor); 
+    Bool_t InitAliITSgeom(AliITSgeom *geom);//Initilize geometry from gGeoManager
+    // Getters and Setters
     // Getters and Setters
+    void    SetVersion(AliITSVersion_t maj,Int_t min) {// Set Major and Minor versions
+        fMajorVersion=maj;fMinorVersion=min;}
     TString GetGeometryName()const {return fName;}// Return geometry name
     void    SetGeometryName(const Char_t *name){fName = name;}// Set Geometry name
     Int_t   GetMajorVersion()const {return (Int_t)fMajorVersion;} // Return geometry major version
@@ -43,21 +53,135 @@ class AliITSInitGeometry : public TObject{
     void    SetSegGeom(Bool_t seg=kTRUE){fSegGeom = seg;}// Set the use of AliITSsegmentation class' instead of AliITSgeomS?D class in fShape
     Bool_t  GetDecoding()const{return fDecode;}// Return flag indecating wether to use new/old decoding
     void    SetDecoding(Bool_t newdec=kFALSE){fDecode = newdec;}// Set flag to use new/old decoding
+     // Set debug level. debug=0 no debug info outputted.
+    void    SetDebug(Int_t debug=0){fDebug=debug;};
+    // Retrun debug value
+    Int_t   GetDebug()const{return fDebug;};
+    // Decode module number into old layer, ladder, and detector numbers
+    void DecodeDetectorLayers(Int_t mod,Int_t &lay,Int_t &lad,Int_t &det);
+    // find module number by layer, and copy numbers
+    void DecodeDetector(Int_t &mod,Int_t lay,Int_t cpn0,
+                        Int_t cpn1,Int_t cpn2) const;
+    // Given module number, find copy numbers.
+    void RecodeDetector(Int_t mod,Int_t &cpn0,Int_t &cpn1,Int_t &cpn2);
+   // fills the string str with the major and minor version number
+    Bool_t WriteVersionString(Char_t *str,Int_t length,
+                              AliITSVersion_t maj,Int_t min,
+                              const Char_t *cvsDate,const Char_t *cvsRev)const;
+    // decodes the string str with the major and minor version number
+    Bool_t ReadVersionString(const Char_t *str,Int_t length,
+                             AliITSVersion_t &maj,Int_t &min,TDatime &dt)const;
 
-    static const Bool_t SPDIsTGeoNative() {return !fgkOldSPDbarrel;}
-    static const Bool_t SDDIsTGeoNative() {return !fgkOldSDDbarrel;}
-    static const Bool_t SSDIsTGeoNative() {return !fgkOldSSDbarrel;}
+    static Bool_t SPDIsTGeoNative() {return !fgkOldSPDbarrel;}
+    static Bool_t SDDIsTGeoNative() {return !fgkOldSDDbarrel;}
+    static Bool_t SSDIsTGeoNative() {return !fgkOldSSDbarrel;}
 
-    static const Bool_t SDDconeIsTGeoNative()   {return ! fgkOldSDDcone;} 
-    static const Bool_t SSDconeIsTGeoNative()   {return ! fgkOldSSDcone;}
-    static const Bool_t SPDshieldIsTGeoNative() {return ! fgkOldSPDshield;}
-    static const Bool_t SDDshieldIsTGeoNative() {return ! fgkOldSDDshield; }
-    static const Bool_t SSDshieldIsTGeoNative() {return ! fgkOldSSDshield;}
-    static const Bool_t ServicesAreTGeoNative() {return ! fgkOldServices;}
-    static const Bool_t SupportIsTGeoNative()   {return ! fgkOldSupports;}
+    static Bool_t SDDconeIsTGeoNative()   {return ! fgkOldSDDcone;} 
+    static Bool_t SSDconeIsTGeoNative()   {return ! fgkOldSSDcone;}
+    static Bool_t SPDshieldIsTGeoNative() {return ! fgkOldSPDshield;}
+    static Bool_t SDDshieldIsTGeoNative() {return ! fgkOldSDDshield; }
+    static Bool_t SSDshieldIsTGeoNative() {return ! fgkOldSSDshield;}
+    static Bool_t ServicesAreTGeoNative() {return ! fgkOldServices;}
+    static Bool_t SupportIsTGeoNative()   {return ! fgkOldSupports;}
 
- private:                 
+ private:
+    // Decode module number into old layer, ladder, and detector numbers
+    void DecodeDetectorLayersvtest2(Int_t mod,Int_t &lay,
+                                   Int_t &lad,Int_t &det){
+        lay=mod+1;lad=det=1;};
+    // find module number by layer, and copy numbers
+    void DecodeDetectorvtest2(Int_t &mod,Int_t lay,Int_t cpn0,
+                             Int_t cpn1,Int_t cpn2) const{
+        mod=lay-1;cpn0=cpn1=cpn2=1;};
+    // Given module number, find copy numbers.
+    void RecodeDetectorvtest2(Int_t mod,Int_t &cpn0,Int_t &cpn1,
+                             Int_t &cpn2){
+        mod=cpn0=cpn1=cpn2=1;};
+    // Decode module number into old layer, ladder, and detector numbers
+    void DecodeDetectorLayersvSPD02(Int_t mod,Int_t &lay,
+                                   Int_t &lad,Int_t &det);
+    // find module number by layer, and copy numbers
+    void DecodeDetectorvSPD02(Int_t &mod,Int_t lay,Int_t cpn0,
+                             Int_t cpn1,Int_t cpn2) const;
+    // Given module number, find copy numbers.
+    void RecodeDetectorvSPD02(Int_t mod,Int_t &cpn0,Int_t &cpn1,
+                             Int_t &cpn2);
+    // Decode module number into old layer, ladder, and detector numbers
+    void DecodeDetectorLayersvSDD03(Int_t mod,Int_t &lay,
+                                   Int_t &lad,Int_t &det);
+    // find module number by layer, and copy numbers
+    void DecodeDetectorvSDD03(Int_t &mod,Int_t lay,Int_t cpn0,
+                             Int_t cpn1,Int_t cpn2) const;
+    // Given module number, find copy numbers.
+    void RecodeDetectorvSDD03(Int_t mod,Int_t &cpn0,Int_t &cpn1,
+                             Int_t &cpn2);
+    // Decode module number into old layer, ladder, and detector numbers
+    void DecodeDetectorLayersvSSD03(Int_t mod,Int_t &lay,
+                                   Int_t &lad,Int_t &det);
+    // find module number by layer, and copy numbers
+    void DecodeDetectorvSSD03(Int_t &mod,Int_t lay,Int_t cpn0,
+                             Int_t cpn1,Int_t cpn2) const;
+    // Given module number, find copy numbers.
+    void RecodeDetectorvSSD03(Int_t mod,Int_t &cpn0,Int_t &cpn1,
+                             Int_t &cpn2);
+    // Decode module number into old layer, ladder, and detector numbers
+    void DecodeDetectorLayersvITS04(Int_t mod,Int_t &lay,
+                                   Int_t &lad,Int_t &det);
+    // find module number by layer, and copy numbers
+    void DecodeDetectorvITS04(Int_t &mod,Int_t lay,Int_t cpn0,
+                             Int_t cpn1,Int_t cpn2) const;
+    // Given module number, find copy numbers.
+    void RecodeDetectorvITS04(Int_t mod,Int_t &cpn0,Int_t &cpn1,
+                             Int_t &cpn2);
+    // Decode module number into old layer, ladder, and detector numbers
+    void DecodeDetectorLayersvPPRcourseasymm(Int_t mod,Int_t &lay,
+                                   Int_t &lad,Int_t &det){
+        lay=lad=det=mod;/*Dummy*/};
+    // find module number by layer, and copy numbers
+    void DecodeDetectorvPPRcourseasymm(Int_t &mod,Int_t lay,Int_t cpn0,
+                             Int_t cpn1,Int_t cpn2) const{
+        mod=lay=cpn0=cpn1=cpn2;/*Dummy*/};
+    // Given module number, find copy numbers.
+    void RecodeDetectorvPPRcourseasymm(Int_t mod,Int_t &cpn0,Int_t &cpn1,
+                             Int_t &cpn2){
+        cpn0=cpn1=cpn2=mod;/*Dummy*/};
+    // Decode module number into old layer, ladder, and detector numbers
+    void DecodeDetectorLayersvPPRasymmFMD(Int_t mod,Int_t &lay,
+                                         Int_t &lad,Int_t &det);
+    // find module number by layer, and copy numbers
+    void DecodeDetectorvPPRasymmFMD(Int_t &mod,Int_t lay,Int_t cpn0,
+                                    Int_t cpn1,Int_t cpn2) const;
+    // Given module number, find copy numbers.
+    void RecodeDetectorvPPRasymmFMD(Int_t mod,Int_t &cpn0,Int_t &cpn1,
+                                    Int_t &cpn2);
+    // Decode module number into old layer, ladder, and detector numbers
+    void DecodeDetectorLayersv11(Int_t mod,Int_t &lay,
+                                         Int_t &lad,Int_t &det)const{
+        lay=lad=det=mod;};
+    // find module number by layer, and copy numbers
+    void DecodeDetectorv11(Int_t &mod,Int_t lay,Int_t cpn0,
+                                    Int_t cpn1,Int_t cpn2) const{
+        mod=lay=cpn0=cpn1=cpn2;};
+    // Given module number, find copy numbers.
+    void RecodeDetectorv11(Int_t mod,Int_t &cpn0,Int_t &cpn1,
+                                    Int_t &cpn2)const{
+        cpn0=cpn1=cpn2=mod;};
+    // Decode module number into old layer, ladder, and detector numbers
+    void DecodeDetectorv11Hybrid(Int_t &mod,Int_t lay,Int_t cpn0,Int_t cpn1,
+                                 Int_t cpn2)const;
+    // find module number by layer, and copy numbers
+    void RecodeDetectorv11Hybrid(Int_t mod,Int_t &cpn0,Int_t &cpn1,
+                                    Int_t &cpn2);
+    // Given module number, find copy numbers.
+    void DecodeDetectorLayersv11Hybrid(Int_t mod,Int_t &lay,Int_t &lad,
+                                    Int_t &det);
+                  
     // Virtual MC code reproduction
+    Bool_t InitAliITSgeomSPD02(AliITSgeom *geom);
+    Bool_t InitAliITSgeomSDD03(AliITSgeom *geom);
+    Bool_t InitAliITSgeomSSD03(AliITSgeom *geom);
+    Bool_t InitAliITSgeomITS04(AliITSgeom *geom);
+    Bool_t InitAliITSgeomtest2(AliITSgeom *geom);
     Bool_t InitAliITSgeomPPRasymmFMD(AliITSgeom *geom);
     Bool_t InitAliITSgeomV11Hybrid(AliITSgeom *geom);
     Bool_t InitAliITSgeomV11(AliITSgeom *geom);
@@ -67,19 +191,17 @@ class AliITSInitGeometry : public TObject{
                                       TArrayD &shapePar,AliITSgeom *geom);
     Bool_t GetTransformation(const TString &volumePath,TGeoHMatrix &mat);
     Bool_t GetShape(const TString &volumePath,TString &shapeType,TArrayD &par);
-    void DecodeDetectorLayers(Int_t mod,Int_t &lay,Int_t &lad,Int_t &det);
-    void DecodeDetector(Int_t &mod,Int_t lay,Int_t cpn0,
-                        Int_t cpn1,Int_t cpn2) const;
-    void RecodeDetector(Int_t mod,Int_t &cpn0,Int_t &cpn1,Int_t &cpn2);
+    void TransposeTGeoHMatrix(TGeoHMatrix *m) const;
 
-    TString   fName;          // Geometry name
-    Int_t           fMinorVersion;  // Geometry minor version
-    AliITSVersion_t fMajorVersion;  // Geometry swich value
-    Bool_t          fTiming;        // Flag to start inilization timing
-    Bool_t          fSegGeom;       // Flag to switch between the old use of
-                              // AliITSgeomS?D class, or AliITSsegmentation
-                              // class in fShape of AliITSgeom class.
-    Bool_t          fDecode;        // Flag for new/old decoding
+    TString         fName;         // Geometry name
+    Int_t           fMinorVersion; // Geometry minor version
+    AliITSVersion_t fMajorVersion; // Geometry swich value
+    Bool_t          fTiming;       // Flag to start inilization timing
+    Bool_t          fSegGeom;      // Flag to switch between the old use of
+                                   // AliITSgeomS?D class, or AliITSsegmentation
+                                   // class in fShape of AliITSgeom class.
+    Bool_t          fDecode;       // Flag for new/old decoding
+    Int_t           fDebug;        // Debug flag
 
     static const Bool_t fgkOldSPDbarrel;   // use old geo for SPD ?
     static const Bool_t fgkOldSDDbarrel;   // use old geo for SDD ?
index ad583c7d740e0e411e3efbffe3187c3336c47cb2..0809817e0982acc2d244b2490cab7a396915ed70 100644 (file)
@@ -1,5 +1,5 @@
-void AliITSPrintRecPoints(TString rfn="galice.root",Int_t mod=-1,
-                         Int_t evnt=-1){
+void AliITSPrintRecPoints(Int_t outtype=1,TString rfn="galice.root",
+                          Int_t mod=-1,Int_t evnt=-1){
   // Macro to print out the recpoints for all or a specific module
 
   // Dynamically link some shared libs
@@ -30,15 +30,38 @@ void AliITSPrintRecPoints(TString rfn="galice.root",Int_t mod=-1,
     cerr<<"AliITSPrintRecPoints.C :  ITS loader not found"<<endl;
     return;
   }
+  cout <<"ITSloader ok"<<endl;
 
+  if(!gGeoManager){
+      gGeoManger = new TGeoManager();
+      gGeoManager->Import("geometry.root","");
+  } // end if
   ITSloader->LoadHits("read");
   ITSloader->LoadDigits("read");
   ITSloader->LoadRecPoints("read");
-  AliITS *ITS = (AliITS*)gAlice->GetDetector("ITS");
+  cout << "loaded hits, digits, and RecPoints"<< endl;
+  AliITS *ITS = 0;
+  ITS = (AliITS*)(gAlice->GetDetector("ITS"));
   if(!ITS){
     cout << "Error: no ITS found. Aborting"<<endl;
     return;
   } // end if !ITS
+  cout <<"ITS="<<ITS<<endl;
+  if(!(ITS->GetDetTypeSim())){
+      cout <<"No AliITSDetTypeSim object found in ITS"<<endl;
+      return;
+  } // end if
+  AliITSgeom *gm=0;
+  gm = ITS->GetITSgeom();
+  if(!gm){
+      cout <<"No AliITSgeom object found in ITS"<<endl;
+      if(!gGeoManager){
+          cout <<"No gGeoManger. Aborting"<<endl;
+          return;
+      }else{
+          ITS->UpdateInternalGeometry(gGeoManager);
+      } // end if
+  } // end if !AliITSgeom
 
   Int_t evNumber1 = 0;
   Int_t evNumber2 = gAlice->GetEventsPerRun();
@@ -47,19 +70,19 @@ void AliITSPrintRecPoints(TString rfn="galice.root",Int_t mod=-1,
     evNumber2 = evnt+1;
   } // end if evnt>=0
   Int_t mod1 = 0;
-  Int_t mod2 = ITS->GetITSgeom()->GetIndexMax();
+  Int_t mod2 = gm->GetIndexMax();
   if(mod>=0){
     mod1 = mod;
     mod2 = mod+1;
   } // end if mod>=0
   TClonesArray *rpa;
   AliITSRecPoint *rp = 0;
-  AliITSDetTypeRec* rec = new AliITSDetTypeRec();
-  rec->SetLoader(ITSloader);
-  rec->SetITSgeom(ITS->GetITSgeom());
+  AliITSDetTypeRec* rec = new AliITSDetTypeRec(ITSloader);
+  //rec->SetITSgeom(gm);
   rec->SetDefaults();
 
   Int_t event,m,i,i2;
+  Float_t xyz[3];
   for(event = evNumber1; event < evNumber2; event++){
     rl->GetEvent(event);
     rec->SetTreeAddress();
@@ -72,10 +95,23 @@ void AliITSPrintRecPoints(TString rfn="galice.root",Int_t mod=-1,
       cout <<  "Event=" << event << " module=" << m <<
        " Number of Recpoints=" << i2 <<endl;
       for(i=0;i<i2;i++){
-       rp = (AliITSRecPoint*)(rpa->At(i));
-       cout << i << " ";
-       rp->Print((ostream*)cout);
-       cout << endl;
+          rp = (AliITSRecPoint*)(rpa->At(i));
+          switch(outtype){
+          case 1:
+              rp->GetGlobalXYZ(xyz);
+              cout << i << " lx=" << rp->GetDetLocalX() 
+                        << " lz=" << rp->GetDetLocalZ() 
+                   << " x=" << rp->GetX() 
+                   << " y=" << rp->GetY()<< " z=" << rp->GetZ() 
+                   <<" gx=" << xyz[0] << " gy="<< xyz[1] <<" gz="<<xyz[2]
+                   << endl;
+              break;
+          default:
+              cout << i << " ";
+              rp->Print((ostream*)cout);
+              cout << endl;
+              break;
+          } // end switch
       } // end for i
     } // end for m
   } // end for event
index 25cd6644b7b08154e0245278037157b319c482c7..abd86e619cab7996fd85742e347fa07fbdac11c0 100644 (file)
@@ -155,11 +155,16 @@ void AliITSRecPoint::Print(ostream *os){
  
     fmt = os->setf(ios::fixed);  // set fixed floating point output
     *os << GetLabel(0) << " " << GetLabel(1) << " " << GetLabel(2) << " ";
-    *os << fXloc << " " << fZloc << " " << fQ << " ";
     fmt = os->setf(ios::scientific); // set scientific for dEdX.
-    *os << fdEdX << " ";
+    *os << GetX() <<" " << GetY() << " " << GetZ() << " " ;
+    *os << GetSigmaY2() << " " << GetSigmaZ2() << " " << GetSigmaYZ() << " ";
+    fmt = os->setf(ios::fixed);
+    *os << GetVolumeId() << " "<< Misalign() /*fIsMisaligned*/ << " ";
+    fmt = os->setf(ios::scientific); // set scientific for dEdX.
+    *os << fXloc << " " << fZloc << " " << fdEdX << " ";
     fmt = os->setf(ios::fixed); // every fixed
-    *os << GetSigmaY2() << " " << GetSigmaZ2();
+    *os << fIndex <<" " << fQ << " "<<fLayer <<" "<<fNz<<" "<<fNy<<" ";
+    *os << fChargeRatio<<" " << fType << " " << fDeltaProb;
     os->flags(fmt); // reset back to old formating.
     return;
 }
@@ -168,17 +173,22 @@ void AliITSRecPoint::Read(istream *is){
 ////////////////////////////////////////////////////////////////////////
 // Standard input format for this class.
 ////////////////////////////////////////////////////////////////////////
-  Int_t lab[4];
-  Float_t hit[5];
-  lab[3] = 0; // ??
-  *is >> lab[0] >> lab[1] >> lab[2] >> hit[0] >> hit[1] >> hit[4];
-  *is >> fdEdX >> hit[2] >> hit[3];
-  Int_t info[3] = {0,0,0};
-  AliITSRecPoint rp(lab,hit,info,kTRUE);
-  *this = rp;
-
-  return;
+    Bool_t mis;
+    Int_t lab[4];
+    Float_t hit[6];
+    lab[3] = 0; // ??
+    *is >> lab[0] >> lab[1] >> lab[2];
+    SetLabel(lab[0],0); SetLabel(lab[1],1); SetLabel(lab[2],2);
+    *is >> hit[0] >> hit[1] >> hit[2] >> hit[3] >> hit[4] >> hit[5];
+    SetX(hit[0]);SetY(hit[1]);SetZ(hit[2]);SetSigmaY2(hit[3]);
+    SetSigmaZ2(hit[4]);//fSigmaYZ=hit[5];
+    *is >> lab[0] >> mis;
+    SetVolumeId(lab[0]);// fIsMisalinged = mis;
+    *is >> fXloc >> fZloc >> fdEdX;
+    *is >> fIndex >> fQ >> fLayer >> fNz >> fNy >> fChargeRatio >> fType;
+    *is >> fDeltaProb;
+
+    return;
 }
 //----------------------------------------------------------------------
 ostream &operator<<(ostream &os,AliITSRecPoint &p){
index f618ab4fca518dc5c4d98ba79b645d16f300f1a1..287e67870e6a5bb3ee18e035a9c132941929d1e8 100644 (file)
@@ -184,13 +184,15 @@ fShape(5,0)          // Array of shapes and detector information.
     //      Int_t itype   the type of transformation kept.
     //                    bit 0 => Standard GEANT
     //                    bit 1 => ITS tracking
-    //                    bit 2 => A change in the coordinate system has been made.
-    //                    others are still to be defined as needed.
-    //      Int_t nlayers The number of ITS layers also set the size of the arrays
-    //      Int_t *nlads  an array of the number of ladders for each layer. This
-    //                    array must be nlayers long.
-    //      Int_t *ndets  an array of the number of detectors per ladder for each
+    //                    bit 2 => A change in the coordinate system 
+    //                    has been made. others are still to be defined 
+    //                    as needed.
+    //      Int_t nlayers The number of ITS layers also set the size of 
+    //                    the arrays
+    //      Int_t *nlads  an array of the number of ladders for each 
     //                    layer. This array must be nlayers long.
+    //      Int_t *ndets  an array of the number of detectors per ladder
+    //                    for each layer. This array must be nlayers long.
     //      Int_t mods    The number of modules. Typically the sum of all the 
     //                    detectors on every layer and ladder.
     // Outputs:
@@ -210,13 +212,15 @@ void AliITSgeom::Init(Int_t itype,Int_t nlayers,const Int_t *nlads,
     //      Int_t itype   the type of transformation kept.
     //                    bit 0 => Standard GEANT
     //                    bit 1 => ITS tracking
-    //                    bit 2 => A change in the coordinate system has been made.
-    //                    others are still to be defined as needed.
-    //      Int_t nlayers The number of ITS layers also set the size of the arrays
-    //      Int_t *nlads  an array of the number of ladders for each layer. This
-    //                    array must be nlayers long.
-    //      Int_t *ndets  an array of the number of detectors per ladder for each
+    //                    bit 2 => A change in the coordinate system 
+    //                    has been made. others are still to be defined 
+    //                    as needed.
+    //      Int_t nlayers The number of ITS layers also set the size of 
+    //                    the arrays
+    //      Int_t *nlads  an array of the number of ladders for each 
     //                    layer. This array must be nlayers long.
+    //      Int_t *ndets  an array of the number of detectors per ladder 
+    //                    for each layer. This array must be nlayers long.
     //      Int_t mods    The number of modules. Typically the sum of all the 
     //                    detectors on every layer and ladder.
     // Outputs:
@@ -466,8 +470,9 @@ void AliITSgeom::WriteNewFile(const char *filename)const{
     *fp << ", kSDD=" << (Int_t) kSDD << ", kSSD=" << (Int_t) kSSD;
     *fp << ", kSSDp=" << (Int_t) kSSDp << ", and kSDDp=" << (Int_t) kSDDp;
     *fp << "*/" << endl;
-    *fp << "Version "<< fVersion.Length()<<" " << fVersion.Data() << endl;//This should be consistent
-                                           // with the geometry version.
+    *fp << "Version "<< fVersion.Length()<<" " << fVersion.Data() << endl;//
+                                                // This should be consistent
+                                                // with the geometry version.
     *fp << "fTrans " << fTrans << endl;
     *fp << "fNmodules " << fNmodules << endl;
     *fp << "fNlayers " << fNlayers << endl;
@@ -563,8 +568,8 @@ fShape(0,0)      // TObjArray of detector geom.
                &l,&a,&d,&x,&y,&z,&o,&p,&q,&r,&s,&t);
         if(l>lm) lm = l;
         if(l<1 || l>fNlayers) {
-            printf("error in file %s layer=%d min. is 1 max is %d Trying new format\n",
-                   filename,l,fNlayers);
+            printf("error in file %s layer=%d min. is 1 max is %d"
+                   " Trying new format\n",filename,l,fNlayers);
             fclose(pf);
             ReadNewFile(filename);
             return;
@@ -600,8 +605,8 @@ fShape(0,0)      // TObjArray of detector geom.
         sscanf(buff,"%d %d %d %f %f %f %f %f %f %f %f %f",
                &l,&a,&d,&x,&y,&z,&o,&p,&q,&r,&s,&t);
         if(l<1 || l>fNlayers) {
-            Warning("AliITSgeom","error in file %s layer=%d min. is 1 max is %d",
-                   filename,l,fNlayers);
+            Warning("AliITSgeom","error in file %s layer=%d"
+                    " min. is 1 max is %d",filename,l,fNlayers);
             continue;
         }// end if l
         id[0] = l;id[1] = a;id[2] = d;
@@ -629,17 +634,19 @@ fShape(0,0)      // TObjArray of detector geom.
     } // end while ever loop
     fclose(pf);
 }
-
 //______________________________________________________________________
-AliITSgeom::AliITSgeom(const AliITSgeom &source) : TObject(source),
-fVersion(source.fVersion),
-fTrans(source.fTrans),
-fNmodules(source.fNmodules),
-fNlayers(source.fNlayers),
-fNlad(source.fNlad),
-fNdet(source.fNdet),
-fGm(source.fGm),
-fShape(source.fShape)
+AliITSgeom::AliITSgeom(const AliITSgeom &source) : 
+TObject(source),
+fVersion(source.fVersion), // Transformation version.
+fTrans(source.fTrans),   // Flag to keep track of which transformation
+fNmodules(source.fNmodules),// The total number of modules
+fNlayers(source.fNlayers), // The number of layers.
+fNlad(source.fNlad),    // Array of the number of ladders/layer(layer)
+fNdet(source.fNdet),    // Array of the number of detector/ladder(layer)
+fGm(source.fGm.GetSize(),source.fGm.LowerBound()),// Structure of 
+                                                  // translation and rotation.
+fShape(source.fShape.GetSize(),source.fShape.LowerBound())// Array of shapes 
+                                                   // and detector information.
 {
     //     The copy constructor for the AliITSgeom class. It calls the
     // = operator function. See the = operator function for more details.
@@ -650,11 +657,37 @@ fShape(source.fShape)
     //     none.
     // Return:
     //     none.
+    Int_t i,n;
 
-  *this = source;  // Just use the = operator for now.
-  return;
+    n = source.fGm.GetLast()+1;
+    for(i=source.fGm.LowerBound();i<n;i++){
+        fGm.AddAt(new AliITSgeomMatrix(*((AliITSgeomMatrix*)(
+                                             source.fGm.At(i)))),i);
+    } // end for i
+    fGm.SetOwner(kTRUE);
+    n = source.fShape.GetLast()+1;
+    for(i=source.fShape.LowerBound();i<n;i++){
+        switch ((AliITSDetector)i){
+        case kSPD :{
+            fShape.AddAt(new AliITSgeomSPD(*((AliITSgeomSPD*)(
+                                                 source.fShape.At(i)))),i);
+        } break;
+        case kSDD : case kSDDp:{
+            fShape.AddAt(new AliITSgeomSDD(*((AliITSgeomSDD*)(
+                                                 source.fShape.At(i)))),i);
+        }break;
+        case kSSD : case kSSDp :{
+            fShape.AddAt(new AliITSgeomSSD(*((AliITSgeomSSD*)(
+                                                 source.fShape.At(i)))),i);
+        }break;
+        default:{
+            AliError(Form("Unknown fShape type number=%d",i));
+        }break;
+        } // end switch
+    } // end for i
+    fShape.SetOwner(kTRUE);
+    return;
 }
-
 //______________________________________________________________________
 AliITSgeom& AliITSgeom::operator=(const AliITSgeom &source){
     //     The = operator function for the AliITSgeom class. It makes an
@@ -680,25 +713,38 @@ AliITSgeom& AliITSgeom::operator=(const AliITSgeom &source){
     this->fVersion  = source.fVersion;
     this->fTrans    = source.fTrans;
     this->fNmodules = source.fNmodules;
-    this->fNlayers = source.fNlayers;
-    this->fNlad.Set(fNlayers,source.fNlad.GetArray());
-    this->fNdet.Set(fNlayers,source.fNdet.GetArray());
-    this->fShape.Expand(source.fShape.GetEntriesFast());
-    for(i=0;i<source.fShape.GetEntriesFast();i++)
-        this->fShape.AddAt(new TObject(*(source.fShape.At(i))),i);
-    this->fShape.SetOwner(kTRUE);
+    this->fNlayers  = source.fNlayers;
+    this->fNlad     = source.fNlad;
+    this->fNdet     = source.fNdet;
     this->fGm.Expand(this->fNmodules);
-    this->fGm.SetOwner(kTRUE);
-    for(i=0;i<this->fNmodules;i++)
-       if(i<0||i>=fGm.GetSize()){
-           Error("ReadNewFile","i<0||i>=fGm.GetSize()=%d",
-                 i,fGm.GetSize());
-           return *this;
-       } // end if
-        this->fGm.AddAt(new TObject(*(source.fGm.At(i))),i);
+    for(i=source.fGm.LowerBound();i<source.fGm.GetLast();i++){
+        fGm.AddAt(new AliITSgeomMatrix(*((AliITSgeomMatrix*)(
+                                             source.fGm.At(i)))),i);
+    } // end for i
+    fGm.SetOwner(kTRUE);
+    this->fShape.Expand(source.fShape.GetEntriesFast());
+    for(i=source.fShape.LowerBound();i<source.fShape.GetLast();i++){
+        switch ((AliITSDetector)i){
+        case kSPD :{
+            fShape.AddAt(new AliITSgeomSPD(*((AliITSgeomSPD*)(
+                                                 source.fShape.At(i)))),i);
+        } break;
+        case kSDD : case kSDDp:{
+            fShape.AddAt(new AliITSgeomSDD(*((AliITSgeomSDD*)(
+                                                 source.fShape.At(i)))),i);
+        }break;
+        case kSSD : case kSSDp :{
+            fShape.AddAt(new AliITSgeomSSD(*((AliITSgeomSSD*)(
+                                                 source.fShape.At(i)))),i);
+        }break;
+        default:{
+            AliError(Form("Unknown fShape type number=%d",i));
+        }break;
+        } // end switch
+    } // end for i
+    fShape.SetOwner(kTRUE);
     return *this;
 }
-
 //______________________________________________________________________
 Int_t AliITSgeom::GetModuleIndex(Int_t lay,Int_t lad,Int_t det)const{
     //      This routine computes the module index number from the layer,
@@ -731,7 +777,8 @@ Int_t AliITSgeom::GetModuleIndex(Int_t lay,Int_t lad,Int_t det)const{
     return -1;
 }
 //______________________________________________________________________
-void AliITSgeom::GetModuleId(Int_t index,Int_t &lay,Int_t &lad,Int_t &det)const{
+void AliITSgeom::GetModuleId(Int_t index,Int_t &lay,Int_t &lad,Int_t &det)
+const{
     //      This routine computes the layer, ladder and detector number 
     // given the module index number. The number of ladders and detectors
     // per layer is determined when this geometry package is constructed,
@@ -845,7 +892,8 @@ Int_t AliITSgeom::GetStartDet(Int_t dtype)const{
     // This assumes that the detector types are different on different layers
     // and that they are not mixed up.
     // Inputs:
-    //    Int_t dtype A detector type number. 0 for SPD, 1 for SDD, and 2 for SSD.
+    //    Int_t dtype A detector type number. 0 for SPD, 1 for SDD, 
+    //                and 2 for SSD.
     // Outputs:
     //    none.
     // Return:
@@ -875,7 +923,8 @@ Int_t AliITSgeom::GetLastDet(Int_t dtype)const{
     // This assumes that the detector types are different on different layers
     // and that they are not mixed up.
     // Inputs:
-    //     Int_t dtype A detector type number. 0 for SPD, 1 for SDD, and 2 for SSD.
+    //     Int_t dtype A detector type number. 0 for SPD, 1 for SDD, 
+    //                 and 2 for SSD.
     // Outputs:
     // Return:
     //     the module index for the last occurrence of that detector type.
@@ -900,6 +949,50 @@ Int_t AliITSgeom::GetLastDet(Int_t dtype)const{
     return 0;
 }
 //______________________________________________________________________
+Bool_t AliITSgeom::IsInside(Int_t module,Double_t point[3])const{
+    // Determins if the give point is inside of the module as defined
+    // by this set of coordinate transforms.
+    // Inputs:
+    //    Int_t    module    The module to be checked
+    //    Double_t point[3]  A 3 vector global point
+    // Outputs:
+    //    none.
+    // Return:
+    //    kTRUE if point is inside of module, kFALSE otherwise.
+    Double_t l[3],dx,dy,dz;
+    AliITSDetector idet = (AliITSDetector)(this->GetGeomMatrix(module)->
+                                           GetDetectorIndex());
+
+    this->GtoL(module,point,l);
+    switch(idet){
+    case kSPD:{
+        AliITSgeomSPD *spd = (AliITSgeomSPD*)(fShape.At((Int_t)idet));
+        dx = spd->GetDx();
+        dy = spd->GetDy();
+        dz = spd->GetDz();}
+        break;
+    case kSDD: case kSDDp:{
+        AliITSgeomSDD *sdd = (AliITSgeomSDD*)(fShape.At((Int_t)idet));
+        dx = sdd->GetDx();
+        dy = sdd->GetDy();
+        dz = sdd->GetDz();}
+        break;
+    case kSSD: case kSSDp:{
+        AliITSgeomSSD *ssd = (AliITSgeomSSD*)(fShape.At((Int_t)idet));
+        dx = ssd->GetDx();
+        dy = ssd->GetDy();
+        dz = ssd->GetDz();}
+        break;
+    default: // Detector not defined.
+        return kFALSE;
+        break;
+    }// end switch
+    if(TMath::Abs(l[0])>dx) return kFALSE;
+    if(TMath::Abs(l[2])>dz) return kFALSE;
+    if(TMath::Abs(l[1])>dy) return kFALSE;
+    return kTRUE;
+}
+//______________________________________________________________________
 void AliITSgeom::PrintComparison(FILE *fp,AliITSgeom *other)const{
     //     This function was primarily created for diagnostic reasons. It
     // print to a file pointed to by the file pointer fp the difference
@@ -919,8 +1012,9 @@ void AliITSgeom::PrintComparison(FILE *fp,AliITSgeom *other)const{
     // rather than zooming quickly past you on a screen. fprintf is used to
     // do the printing. The fShapeIndex difference is not printed at this time.
     // Inputs:
-    //    FILE *fp           A file pointer to an opened file for writing in which
-    //                       the results of the comparison will be written.
+    //    FILE *fp           A file pointer to an opened file for writing 
+    //                       in which the results of the comparison will 
+    //                       be written.
     //    AliITSgeom *other  The other AliITSgeom class to which this one is
     //                       being compared.
     // Outputs:
@@ -984,8 +1078,9 @@ void AliITSgeom::PrintData(FILE *fp,Int_t lay,Int_t lad,Int_t det)const{
     // is given to the user. The output it written to the file pointed
     // to by the file pointer fp. This can be set to stdout if you want.
     // Inputs:
-    //     FILE *fp           A file pointer to an opened file for writing in which
-    //                        the results of the comparison will be written.
+    //     FILE *fp           A file pointer to an opened file for 
+    //                        writing in which the results of the 
+    //                        comparison will be written.
     //     Int_t lay          The layer number. Starting from 1.
     //     Int_t lad          The ladder number. Starting from 1.
     //     Int_t det          The detector number. Starting from 1.
@@ -1009,109 +1104,109 @@ void AliITSgeom::PrintData(FILE *fp,Int_t lay,Int_t lad,Int_t det)const{
     return;
 }
 //______________________________________________________________________
-ofstream & AliITSgeom::PrintGeom(ofstream &rb)const{
+void AliITSgeom::PrintGeom(ostream *wb)const{
     //     Stream out an object of class AliITSgeom to standard output.
     // Intputs:
-    //     ofstream &rb    The output streaming buffer.
+    //     ofstream *wb    The output streaming buffer.
     // Outputs:
     //     none.
     // Return:
-    //     ofstream &rb    The output streaming buffer.
+    //     none.
     Int_t i,nshapes;
 
-    rb.setf(ios::scientific);
-    rb << fTrans << " ";
-    rb << fNmodules << " ";
-    rb << fNlayers << " ";
-    for(i=0;i<fNlayers;i++) rb << fNlad[i] << " ";
-    for(i=0;i<fNlayers;i++) rb << fNdet[i] << "\n";
+    wb->setf(ios::scientific);
+    *wb << fTrans << " ";
+    *wb << fNmodules << " ";
+    *wb << fNlayers << " ";
+    for(i=0;i<fNlayers;i++) *wb << fNlad[i] << " ";
+    for(i=0;i<fNlayers;i++) *wb << fNdet[i] << "\n";
     for(i=0;i<fNmodules;i++) {
-        rb <<setprecision(16) << *(GetGeomMatrix(i)) << "\n";
+        *wb <<setprecision(16) << *(GetGeomMatrix(i)) << "\n";
     } // end for i
     nshapes = fShape.GetEntries();
-    rb << nshapes <<endl;
+    *wb << nshapes <<endl;
     for(i=0;i<nshapes;i++) if(fShape.At(i)!=0) switch (i){
     case kSPD:
-        rb << kSPD <<","<< (AliITSgeomSPD*)(fShape.At(kSPD));
+        *wb << kSPD <<","<< (AliITSgeomSPD*)(fShape.At(kSPD));
         break;
     case kSDD:
-        rb << kSDD <<","<< (AliITSgeomSDD*)(fShape.At(kSDD));
+        *wb << kSDD <<","<< (AliITSgeomSDD*)(fShape.At(kSDD));
         break;
     case kSSD:
-        rb << kSSD <<","<< (AliITSgeomSSD*)(fShape.At(kSSD));
+        *wb << kSSD <<","<< (AliITSgeomSSD*)(fShape.At(kSSD));
         break;
     case kSSDp:
-        rb << kSSDp <<","<< (AliITSgeomSSD*)(fShape.At(kSSDp));
+        *wb << kSSDp <<","<< (AliITSgeomSSD*)(fShape.At(kSSDp));
         break;
     case kSDDp:
-        rb << kSDDp <<","<< (AliITSgeomSDD*)(fShape.At(kSDDp));
+        *wb << kSDDp <<","<< (AliITSgeomSDD*)(fShape.At(kSDDp));
         break;
     } // end for i / switch
-    return rb;
+    return;
 }
 //______________________________________________________________________
-ifstream & AliITSgeom::ReadGeom(ifstream &rb){
+void AliITSgeom::ReadGeom(istream *rb){
     //     Stream in an object of class AliITSgeom from standard input.
     // Intputs:
-    //     ifstream &rb    The input streaming buffer.
+    //     ifstream *rb    The input streaming buffer.
     // Outputs:
     //     none.
     // Return:
-    //     ifstream &rb    The input streaming buffer.
+    //     none.
     Int_t i,j;
 
     fGm.Clear();
 
-    rb >> fTrans >> fNmodules >> fNlayers;
+    *rb >> fTrans >> fNmodules >> fNlayers;
     fNlad.Set(fNlayers);
     fNdet.Set(fNlayers);
-    for(i=0;i<fNlayers;i++) rb >> fNlad[i];
-    for(i=0;i<fNlayers;i++) rb >> fNdet[i];
+    for(i=0;i<fNlayers;i++) *rb >> fNlad[i];
+    for(i=0;i<fNlayers;i++) *rb >> fNdet[i];
     fGm.Expand(fNmodules);
     fGm.SetOwner(kTRUE);
     for(i=0;i<fNmodules;i++){
        if(i<0||i>=fGm.GetSize()){
            Error("ReadGeom","i<0||i>=fGm.GetSize()=%d",
                  i,fGm.GetSize());
-           return rb;
+           return;
        } // end if
         fGm.AddAt(new AliITSgeomMatrix,i);
-        rb >> *(GetGeomMatrix(i));
+        *rb >> *(GetGeomMatrix(i));
     } // end for i
-    rb >> i;
+    *rb >> i;
     fShape.Expand(i);
     fShape.SetOwner(kTRUE);
     for(i=0;i<fShape.GetEntries();i++) {
-        rb >> j;
+        *rb >> j;
         switch (j){
         case kSPD:{
             AliITSgeomSPD *s = new AliITSgeomSPD();
-            rb >> *s;
+            *rb >> *s;
             fShape.AddAt(s,kSPD);}
             break;
         case kSDD:{
             AliITSgeomSDD *s = new AliITSgeomSDD();
-            rb >> *s;
+            *rb >> *s;
             fShape.AddAt(s,kSDD);}
             break;
         case kSSD:{
             AliITSgeomSSD *s = new AliITSgeomSSD();
-            rb >> *s;
+            *rb >> *s;
             fShape.AddAt(s,kSSD);}
             break;
         case kSSDp:{
             AliITSgeomSSD *s = new AliITSgeomSSD();
-            rb >> *s;
+            *rb >> *s;
             fShape.AddAt(s,kSSDp);}
             break;
         case kSDDp:{
             AliITSgeomSDD *s = new AliITSgeomSDD();
-            rb >> *s;
+            *rb >> *s;
             fShape.AddAt(s,kSDDp);}
             break;
         } // end  switch
     } //  end for i
-    return rb;
+    return;
 }
 //______________________________________________________________________
 //     The following routines modify the transformation of "this"
@@ -1135,8 +1230,8 @@ void AliITSgeom::GlobalChange(const Float_t *tran,const Float_t *rot){
     // respect to the beam line, except for an effective rotation about the
     // beam axis which will just rotate the ITS as a hole about the beam axis.
     // Intputs:
-    //     Float_t *tran   A 3 element array representing the global translations.
-    //                     the elements are x,y,z in cm.
+    //     Float_t *tran   A 3 element array representing the global 
+    //                     translations. the elements are x,y,z in cm.
     //     Float_t *rot    A 3 element array representing the global rotation
     //                     angles about the three axis x,y,z in radians
     // Outputs:
@@ -1184,8 +1279,9 @@ void AliITSgeom::GlobalCylindericalChange(const Float_t *tran,
     // line, except for an effective rotation about the beam axis which will
     // just rotate the ITS as a hole about the beam axis.
     // Intputs:
-    //     Float_t *tran   A 3 element array representing the global translations.
-    //                     the elements are r,theta,z in cm/radians.
+    //     Float_t *tran   A 3 element array representing the global 
+    //                     translations. the elements are r,theta,z in 
+    //                     cm/radians.
     //     Float_t *rot    A 3 element array representing the global rotation
     //                     angles about the three axis x,y,z in radians
     // Outputs:
@@ -1227,10 +1323,12 @@ void AliITSgeom::RandomChange(const Float_t *stran,const Float_t *srot){
     // x y and z translations, and the three element array srot,
     // for the three rotation about the axis x y and z.
     // Intputs:
-    //     Float_t *stran  A 3 element array representing the global translations
-    //                     variances. The elements are x,y,z in cm.
+    //     Float_t *stran  A 3 element array representing the global 
+    //                     translations variances. The elements are x,
+    //                     y,z in cm.
     //     Float_t *srot   A 3 element array representing the global rotation
-    //                     angles variances about the three axis x,y,z in radians.
+    //                     angles variances about the three axis x,y,z in 
+    //                     radians.
     // Outputs:
     //     none.
     // Return:
@@ -1265,10 +1363,12 @@ void AliITSgeom::RandomCylindericalChange(const Float_t *stran,
     // in detector position allow for the simulation of a random uncertainty
     // in the detector positions of the ITS.
     // Intputs:
-    //     Float_t *stran  A 3 element array representing the global translations
-    //                     variances. The elements are r,theta,z in cm/radians.
+    //     Float_t *stran  A 3 element array representing the global 
+    //                     translations variances. The elements are r,
+    //                     theta,z in cm/radians.
     //     Float_t *srot   A 3 element array representing the global rotation
-    //                     angles variances about the three axis x,y,z in radians.
+    //                     angles variances about the three axis x,y,z in 
+    //                     radians.
     // Outputs:
     //     none.
     // Return:
@@ -1482,31 +1582,83 @@ Double_t AliITSgeom::GetAverageRadiusOfLayer(Int_t layer,Double_t &range)const{
     return r;
 }
 //_______________________________________________________________________
-void AliITSgeom::DetLToTrackingV2(Int_t md, Float_t xin, Float_t zin, Float_t &yout, Float_t &zout) {
+void AliITSgeom::DetLToTrackingV2(Int_t md,Float_t xin,Float_t zin,
+                                  Float_t &yout,Float_t &zout) {
 
-  //Conversion from local coordinates on detectors to local
-  //coordinates used for tracking ("v2")
-  Float_t x,y,z; 
-  Double_t rt[9];
-  GetTrans(md,x,y,z);
-  GetRotMatrix(md,rt);
-  Double_t al=TMath::ATan2(rt[1],rt[0])+TMath::Pi();
-  yout=-(-xin+(x*TMath::Cos(al)+y*TMath::Sin(al)));
-  if ( md<(GetModuleIndex(2,1,1)) ) yout*=-1; 
-  zout=-zin+(Double_t)z; 
-}
+    //Conversion from local coordinates on detectors to local
+    //coordinates used for tracking ("v2")
+    // Inputs:
+    //   Int_t   md      Module number
+    //   Float_t xin     Standard local coordinate x
+    //   Float_t zin     Standard local coordinate z
+    // Output:
+    //   Float_t yout    Tracking local coordinate y
+    //   Float_t zout    Tracking local coordinate z
+    // Return:
+    //   none.
+    Float_t x,y,z;
+    Double_t rt[9],al;
 
+    GetTrans(md,x,y,z);
+    GetRotMatrix(md,rt);
+    al = TMath::ATan2(rt[1],rt[0])+TMath::Pi();
+    yout = -(-xin+(x*((Float_t)TMath::Cos(al))+y*((Float_t)TMath::Sin(al))));
+    if(md<(GetModuleIndex(2,1,1))) yout *= -1; 
+    zout = -zin+z; 
+}
 //_______________________________________________________________________
-void AliITSgeom::TrackingV2ToDetL(Int_t md,Float_t yin,Float_t zin,Float_t &xout,Float_t &zout) {
-  //Conversion from local coordinates used for tracking ("v2") to
-  //local detector coordinates
-  
-  Float_t x,y,z; Double_t rt[9];
-  GetTrans(md,x,y,z);
-  GetRotMatrix(md,rt);
-  Double_t al=TMath::ATan2(rt[1],rt[0])+TMath::Pi();
-  xout=yin;
-  if( md<(GetModuleIndex(2,1,1)) ) xout=-xout;
-  xout+=(x*TMath::Cos(al)+y*TMath::Sin(al));
-  zout=-zin+(Double_t)z; 
+void AliITSgeom::TrackingV2ToDetL(Int_t md,Float_t yin,Float_t zin,
+                                  Float_t &xout,Float_t &zout) {
+    //Conversion from local coordinates used for tracking ("v2") to
+    //local detector coordinates  
+    // Inputs:
+    //   Int_t   md      Module number
+    //   Float_t yin     Tracking local coordinate y
+    //   Float_t zin     Tracking local coordinate z
+    // Output:
+    //   Float_t xout    Standard local coordinate x
+    //   Float_t zout    Standard local coordinate z
+    // Return:
+    //   none.
+    Float_t x,y,z;
+    Double_t rt[9],al;
+
+    GetTrans(md,x,y,z);
+    GetRotMatrix(md,rt);
+    al = TMath::ATan2(rt[1],rt[0])+TMath::Pi();
+    xout = yin;
+    if(md<(GetModuleIndex(2,1,1))) xout = -xout;
+    xout += (x*((Float_t)TMath::Cos(al))+y*((Float_t)TMath::Sin(al)));
+    zout  = -zin+z; 
 }
+//----------------------------------------------------------------------
+ostream &operator<<(ostream &os,AliITSgeom &p){
+    // Standard output streaming function.
+    // Inputs:
+    //   ostream    os   The output stream
+    //   AliITSgeom p    The AliITSgeom class to be printed out
+    // Outputs:
+    //   none.
+    // Return:
+    //   The input stream
+
+    p.PrintGeom(&os);
+    return os;
+}
+//----------------------------------------------------------------------
+istream &operator>>(istream &is,AliITSgeom &r){
+    // Standard input streaming function.
+    // Inputs:
+    //   istream    is  The input stream
+    //   AliITSgeom p   The AliITSgeom class to be filled from this 
+    //                  input stream
+    // Outputs:
+    //   none.
+    // Return:
+    //   The input stream
+
+    r.ReadGeom(&is);
+    return is;
+}
+//----------------------------------------------------------------------
+
index e05028e3e0fcfa0928bc4632c6ba5d25abf69fed..470d396cfd0395dd528200d5da7bf2bcb3e40eab 100644 (file)
@@ -24,8 +24,7 @@
 #include <TString.h>
 #include <TArrayI.h>
 #include <TMath.h>
-
-
+//
 #include "AliITSgeomMatrix.h"
 
 typedef enum {kND=-1,kSPD=0, kSDD=1, kSSD=2, kSSDp=3,kSDDp=4} AliITSDetector;
@@ -76,10 +75,16 @@ class AliITSgeom : public TObject {
     //
     //     This function returns a pointer to the particular AliITSgeomMatrix
     // class for a specific module index.
-    AliITSgeomMatrix *GetGeomMatrix(Int_t index){if(index<fGm.GetSize()&&index>=0)
-        return (AliITSgeomMatrix*)(fGm.At(index));else Error("GetGeomMatrix","index=%d<0||>=GetSize()=%d",index,fGm.GetSize());return 0;}
-    AliITSgeomMatrix *GetGeomMatrix(Int_t index)const{if(index<fGm.GetSize()&&index>=0)
-        return (AliITSgeomMatrix*)(fGm.At(index));else Error("GetGeomMatrix","index=%d<0||>=GetSize()=%d",index,fGm.GetSize());return 0;}
+    AliITSgeomMatrix *GetGeomMatrix(Int_t index){if(index<fGm.GetSize()&&
+                                                    index>=0)
+        return (AliITSgeomMatrix*)(fGm.At(index));else 
+            Error("GetGeomMatrix","index=%d<0||>=GetSize()=%d",
+                  index,fGm.GetSize());return 0;}
+    AliITSgeomMatrix *GetGeomMatrix(Int_t index)const{if(index<fGm.GetSize()
+                                                         &&index>=0)
+        return (AliITSgeomMatrix*)(fGm.At(index));else 
+            Error("GetGeomMatrix","index=%d<0||>=GetSize()=%d",
+                  index,fGm.GetSize());return 0;}
     // This function find and return the number of detector types only.
     Int_t GetNDetTypes()const{Int_t max;return GetNDetTypes(max);};
     // This function find and return the number of detector types and the
@@ -244,6 +249,9 @@ class AliITSgeom : public TObject {
     void  SetRotMatrix(Int_t index,Double_t *mat){Double_t rot[3][3];
           for(Int_t i=0;i<3;i++)for(Int_t j=0;j<3;j++) rot[i][j]=mat[3*i+j];
           GetGeomMatrix(index)->SetMatrix(rot);}
+    // Return the normal for a specific module
+    void GetGlobalNormal(Int_t index,Double_t n[3]){
+        GetGeomMatrix(index)->GetGlobalNormal(n[0],n[1],n[2]);}
     //
     //     Will define fShape if it isn't already defined.
     void DefineShapes(Int_t size=5){fShape.Expand(size);}
@@ -272,6 +280,9 @@ class AliITSgeom : public TObject {
     // AliITSgeomSDD, or AliITSgeomSSD, for example.
     virtual TObject *GetShape(Int_t lay,Int_t lad,Int_t det)
         {return GetShape(GetModuleIndex(lay,lad,det));}
+    //     Determine if a give point is inside of a detectors sensitive
+    // volume (as defined by these transformations).
+    virtual Bool_t IsInside(Int_t module,Double_t point[3])const;
     //
     //  Setters
     //     Sets the rotation angles and matrix for a give module index
@@ -570,8 +581,8 @@ class AliITSgeom : public TObject {
     // Global coordinate system for the detector id[3].
     // The global and local coordinate are given in two Double point
     // arrays g[3], and l[3].
-    void LtoGMomentumTracking(const Int_t *id,const Double_t *l,Double_t *g)const{
-        LtoGMomentumTracking(GetModuleIndex(id),l,g);}
+    void LtoGMomentumTracking(const Int_t *id,const Double_t *l,Double_t *g)
+        const{LtoGMomentumTracking(GetModuleIndex(id),l,g);}
     //     Transforms of momentum types of quantities from the detector
     // local coordinate system (used for ITS tracking) to the ALICE
     // Global coordinate system for the detector layer ladder and detector
@@ -592,8 +603,8 @@ class AliITSgeom : public TObject {
     // to another detector local coordinate system for the detector
     // id1[3] to the detector id2[3]. The local coordinates are given
     // in two Double point arrays l1[3], and l2[3].
-    void LtoL(const Int_t *id1,const Int_t *id2,Double_t *l1,Double_t *l2)const{
-        LtoL(GetModuleIndex(id1[0],id1[1],id1[2]),
+    void LtoL(const Int_t *id1,const Int_t *id2,Double_t *l1,Double_t *l2)
+        const{LtoL(GetModuleIndex(id1[0],id1[1],id1[2]),
               GetModuleIndex(id2[0],id2[1],id2[2]),l1,l2);}
     //
     //     Transforms from one detector local coordinate system (used for
@@ -656,7 +667,8 @@ class AliITSgeom : public TObject {
     // system. The specific detector is determined by the module index
     // number.
     void GtoLErrorMatrix(Int_t index,const Double_t **g,Double_t **l)const{
-        GetGeomMatrix(index)->GtoLPositionError((Double_t (*)[3])g,(Double_t (*)[3])l);}
+        GetGeomMatrix(index)->GtoLPositionError(
+            (Double_t (*)[3])g,(Double_t (*)[3])l);}
     //
     //     Transforms a matrix, like an Uncertainty or Error matrix from
     // the ALICE Global coordinate system to a detector local coordinate
@@ -674,7 +686,18 @@ class AliITSgeom : public TObject {
     // system. The specific detector is determined by the module index
     // number.
     void LtoGErrorMatrix(Int_t index,const Double_t **l,Double_t **g)const{
-        GetGeomMatrix(index)->LtoGPositionError((Double_t (*)[3])l,(Double_t (*)[3])g);}
+        GetGeomMatrix(index)->LtoGPositionError(
+            (Double_t (*)[3])l,(Double_t (*)[3])g);}
+    //
+    //     Transforms a matrix, like an Uncertainty or Error matrix from
+    // the detector local coordinate system to a ALICE Global coordinate
+    // system. The specific detector is determined by the module index
+    // number.
+    void LtoGErrorMatrix(Int_t index,const Double_t l[3][3],Double_t g[3][3])
+        const{
+        GetGeomMatrix(index)->LtoGPositionError(
+            (Double_t (*)[3])l,(Double_t (*)[3])g);}
+
     //
     //     Transforms a matrix, like an Uncertainty or Error matrix from
     // the detector local coordinate system (used by ITS tracking) to a
@@ -682,10 +705,21 @@ class AliITSgeom : public TObject {
     // by the module index number.
     void LtoGErrorMatrixTracking(Int_t index,const Double_t **l,
                                  Double_t **g)const{
-        if(IsGeantToTracking()) GetGeomMatrix(index)->LtoGPositionError((
-                                   Double_t (*)[3])g,(Double_t (*)[3])l);
-        else GetGeomMatrix(index)->LtoGPositionErrorTracking((Double_t (*)[3])l,
-                                                          (Double_t (*)[3])g);}
+        if(IsGeantToTracking()) GetGeomMatrix(index)->LtoGPositionError(
+            (Double_t (*)[3])g,(Double_t (*)[3])l);
+        else GetGeomMatrix(index)->LtoGPositionErrorTracking(
+            (Double_t (*)[3])l,(Double_t (*)[3])g);}
+    //
+    //     Transforms a matrix, like an Uncertainty or Error matrix from
+    // the detector local coordinate system (used by ITS tracking) to a
+    // ALICE Global coordinate system. The specific detector is determined
+    // by the module index number.
+    void LtoGErrorMatrixTracking(Int_t index,const Double_t l[3][3],
+                                 Double_t g[3][3])const{
+        if(IsGeantToTracking()) GetGeomMatrix(index)->LtoGPositionError(
+            (Double_t (*)[3])g,(Double_t (*)[3])l);
+        else GetGeomMatrix(index)->LtoGPositionErrorTracking(
+            (Double_t (*)[3])l,(Double_t (*)[3])g);}
     //
     //     Transforms a matrix, like an Uncertainty or Error matrix from
     // one detector local coordinate system to another detector local
@@ -744,7 +778,9 @@ class AliITSgeom : public TObject {
     void RandomCylindericalChange(const Float_t *stran,const Float_t *srot);
     // This function converts these transformations from Alice global and
     // local to Tracking global and local.
-    void GeantToTracking(const AliITSgeom &source); // This converts the geometry
+    //
+    // This converts the geometry
+    void GeantToTracking(const AliITSgeom &source);
     //  Other routines.
     // This routine prints, to a file, the difference between this class
     // and "other".
@@ -753,17 +789,18 @@ class AliITSgeom : public TObject {
     void PrintData(FILE *fp,Int_t lay,Int_t lad,Int_t det)const;
     // This function prints out this class in a single stream. This steam
     // can be read by ReadGeom.
-    ofstream &PrintGeom(ofstream &out)const;
+    void PrintGeom(ostream *out)const;
     // This function reads in that single steam printed out by PrintGeom.
-    ifstream &ReadGeom(ifstream &in);
+    void ReadGeom(istream *in);
 
     //Conversion from det. local coordinates to local ("V2") coordinates
     //used for tracking
 
-    void DetLToTrackingV2(Int_t md, Float_t xin, Float_t zin, Float_t &yout, Float_t &zout); 
-
-    void TrackingV2ToDetL(Int_t md,Float_t yin,Float_t zin,Float_t &xout,Float_t &zout);
+    void DetLToTrackingV2(Int_t md,Float_t xin,Float_t zin,
+                          Float_t &yout, Float_t &zout); 
 
+    void TrackingV2ToDetL(Int_t md,Float_t yin,Float_t zin,
+                          Float_t &xout,Float_t &zout);
 
  private:
     TString    fVersion; // Transformation version.
@@ -776,6 +813,9 @@ class AliITSgeom : public TObject {
     TObjArray  fShape;   // Array of shapes and detector information.
 
     ClassDef(AliITSgeom,3) // ITS geometry class
-};
+}; 
+// Input and output function for standard C++ input/output.
+ostream& operator<<(ostream &os,AliITSgeom &source);
+istream& operator>>(istream &os,AliITSgeom &source);
 
 #endif
index 99cb5436cd9c957c9fbb731d12462fba13e6c3f7..0f633204a5dfb7c0bfc61ac197a7365153ca33aa 100644 (file)
@@ -47,7 +47,7 @@ $Id$
 ClassImp(AliITSgeomMatrix)
 //----------------------------------------------------------------------
 AliITSgeomMatrix::AliITSgeomMatrix():
-TObject(),
+TObject(),         // Base Class.
 fDetectorIndex(0), // Detector type index (like fShapeIndex was)
 fid(),       // layer, ladder, detector numbers.
 frot(),      //! vector of rotations about x,y,z [radians].
@@ -84,17 +84,21 @@ fPath(){     // Path in geometry to this module
        fid[i] = 0;
        frot[i] = ftran[i] = 0.0;
        for(j=0;j<3;j++) fm[i][j] = 0.0;
-       fCylR = fCylPhi = 0.0;
     }// end for i
     fm[0][0] = fm[1][1] = fm[2][2] = 1.0;
 }
 
 //----------------------------------------------------------------------
 AliITSgeomMatrix::AliITSgeomMatrix(const AliITSgeomMatrix &source) : 
-TObject(source),
-fDetectorIndex(source.fDetectorIndex),
-fCylR(source.fCylR),
-fCylPhi(source.fCylPhi),
+TObject(source),         // Base Class.
+fDetectorIndex(source.fDetectorIndex),// Detector type index (like 
+                                      // fShapeIndex was)
+fid(),       // layer, ladder, detector numbers.
+frot(),      //! vector of rotations about x,y,z [radians].
+ftran(),     // Translation vector of module x,y,z.
+fCylR(source.fCylR),  //! R Translation in Cylinderical coordinates
+fCylPhi(source.fCylPhi),//! Phi Translation vector in Cylindrical coord.
+fm(),        // Rotation matrix based on frot.
 fPath(source.fPath){
     // The standard Copy constructor. This make a full / proper copy of
     // this class.
@@ -104,13 +108,14 @@ fPath(source.fPath){
     //    none.
     // Return:
     //    A copy constructes AliITSgeomMatrix class.
-       Int_t i,j;
-       for(i=0;i<3;i++){
-               this->fid[i]     = source.fid[i];
-               this->frot[i]    = source.frot[i];
-               this->ftran[i]   = source.ftran[i];
-               for(j=0;j<3;j++) this->fm[i][j] = source.fm[i][j];
-       }// end for i
+    Int_t i,j;
+
+    for(i=0;i<3;i++){
+        this->fid[i]     = source.fid[i];
+        this->frot[i]    = source.frot[i];
+        this->ftran[i]   = source.ftran[i];
+        for(j=0;j<3;j++) this->fm[i][j] = source.fm[i][j];
+    }// end for i
 }
 //----------------------------------------------------------------------
 AliITSgeomMatrix& AliITSgeomMatrix::operator=(const AliITSgeomMatrix &source){
@@ -124,27 +129,26 @@ AliITSgeomMatrix& AliITSgeomMatrix::operator=(const AliITSgeomMatrix &source){
     //    none.
     // Return:
     //    A copy of the source AliITSgeomMatrix class.
-  if(this == &source)return *this;
-  Int_t i,j;
 
-  this->fDetectorIndex = source.fDetectorIndex;
-  this->fCylR      = source.fCylR;
-  this->fCylPhi    = source.fCylPhi;
-  for(i=0;i<3;i++){
-    this->fid[i]     = source.fid[i];
-    this->frot[i]    = source.frot[i];
-    this->ftran[i]   = source.ftran[i];
+    if(this == &source)return *this;
+    Int_t i,j;
 
-    for(j=0;j<3;j++) this->fm[i][j] = source.fm[i][j];
-  }
-  this->fPath   = source.fPath;
-  return *this;
+    this->fDetectorIndex = source.fDetectorIndex;
+    this->fCylR      = source.fCylR;
+    this->fCylPhi    = source.fCylPhi;
+    for(i=0;i<3;i++){
+        this->fid[i]     = source.fid[i];
+        this->frot[i]    = source.frot[i];
+        this->ftran[i]   = source.ftran[i];
+        for(j=0;j<3;j++) this->fm[i][j] = source.fm[i][j];
+    } // end for i
+    this->fPath   = source.fPath;
+    return *this;
 }
-
 //----------------------------------------------------------------------
 AliITSgeomMatrix::AliITSgeomMatrix(Int_t idt,const Int_t id[3],
                         const Double_t rot[3],const Double_t tran[3]):
-TObject(),
+TObject(),           // Base class
 fDetectorIndex(idt), // Detector type index (like fShapeIndex was)
 fid(),       // layer, ladder, detector numbers.
 frot(),      //! vector of rotations about x,y,z [radians].
@@ -192,7 +196,7 @@ fPath(){     // Path in geometry to this moduel
 AliITSgeomMatrix::AliITSgeomMatrix(Int_t idt, const Int_t id[3],
                                    Double_t matrix[3][3],
                                    const Double_t tran[3]):
-TObject(),
+TObject(),            // Base class
 fDetectorIndex(idt), // Detector type index (like fShapeIndex was)
 fid(),       // layer, ladder, detector numbers.
 frot(),      //! vector of rotations about x,y,z [radians].
@@ -326,11 +330,15 @@ void AliITSgeomMatrix::MatrixFromSixAngles(const Double_t *ang){
 AliITSgeomMatrix::AliITSgeomMatrix(const Double_t rotd[6]/*degrees*/,
                                    Int_t idt,const Int_t id[3],
                                    const Double_t tran[3]):
-TObject(),
-fDetectorIndex(idt),
-fCylR(0.),
-fCylPhi(0.),
-fPath(){
+TObject(),            // Base class
+fDetectorIndex(idt), // Detector type index (like fShapeIndex was)
+fid(),       // layer, ladder, detector numbers.
+frot(),      //! vector of rotations about x,y,z [radians].
+ftran(),     // Translation vector of module x,y,z.
+fCylR(0.0),  //! R Translation in Cylinderical coordinates
+fCylPhi(0.0),//! Phi Translation vector in Cylindrical coord.
+fm(),        // Rotation matrix based on frot.
+fPath(){     // Path in geometry to this module
     // This is a constructor for the AliITSgeomMatrix class. The matrix 
     // is defined by the 6 GEANT 3.21 rotation angles [degrees], and 
     // the translation vector tran [cm]. In addition the layer, ladder, 
@@ -362,7 +370,6 @@ fPath(){
     if(fCylPhi<0.0) fCylPhi += TMath::Pi();
     this->MatrixFromSixAngles(rotd);
 }
-
 //----------------------------------------------------------------------
 void AliITSgeomMatrix::AngleFromMatrix(){
     // Computes the angles from the rotation matrix up to a phase of 
@@ -392,7 +399,6 @@ void AliITSgeomMatrix::AngleFromMatrix(){
     frot[2] = rz;
     return;
 }
-
 //----------------------------------------------------------------------
 void AliITSgeomMatrix::MatrixFromAngle(){
     // Computes the Rotation matrix from the angles [radians] kept in this
@@ -411,23 +417,57 @@ void AliITSgeomMatrix::MatrixFromAngle(){
     //   none
     // Return:
     //   none
-   Double_t sx,sy,sz,cx,cy,cz;
-
-   sx = TMath::Sin(frot[0]); cx = TMath::Cos(frot[0]);
-   sy = TMath::Sin(frot[1]); cy = TMath::Cos(frot[1]);
-   sz = TMath::Sin(frot[2]); cz = TMath::Cos(frot[2]);
-   fm[0][0] = +cz*cy;             // fr[0]
-   fm[0][1] = +cz*sy*sx - sz*cx;  // fr[1]
-   fm[0][2] = +cz*sy*cx + sz*sx;  // fr[2]
-   fm[1][0] = +sz*cy;             // fr[3]
-   fm[1][1] = +sz*sy*sx + cz*cx;  // fr[4]
-   fm[1][2] = +sz*sy*cx - cz*sx;  // fr[5]
-   fm[2][0] = -sy;                // fr[6]
-   fm[2][1] = +cy*sx;             // fr[7]
-   fm[2][2] = +cy*cx;             // fr[8]
+    Double_t sx,sy,sz,cx,cy,cz;
 
+    sx = TMath::Sin(frot[0]); cx = TMath::Cos(frot[0]);
+    sy = TMath::Sin(frot[1]); cy = TMath::Cos(frot[1]);
+    sz = TMath::Sin(frot[2]); cz = TMath::Cos(frot[2]);
+    fm[0][0] = +cz*cy;             // fr[0]
+    fm[0][1] = +cz*sy*sx - sz*cx;  // fr[1]
+    fm[0][2] = +cz*sy*cx + sz*sx;  // fr[2]
+    fm[1][0] = +sz*cy;             // fr[3]
+    fm[1][1] = +sz*sy*sx + cz*cx;  // fr[4]
+    fm[1][2] = +sz*sy*cx - cz*sx;  // fr[5]
+    fm[2][0] = -sy;                // fr[6]
+    fm[2][1] = +cy*sx;             // fr[7]
+    fm[2][2] = +cy*cx;             // fr[8]
 }
+//----------------------------------------------------------------------
+void AliITSgeomMatrix::SetEulerAnglesChi(const Double_t ang[3]){
+    // Computes the Rotation matrix from the Euler angles [radians], 
+    // Chi-convention, kept in this class. The matrix used in 
+    // AliITSgeomMatrix::SetEulerAnglesChi and 
+    // its inverse AliITSgeomMatrix::GetEulerAnglesChi() are defined in 
+    // the following ways, R = Rb*Rc*Rd (M=R*L+T) where
+    //     C2 +S2  0       1  0    0       C0 +S0  0
+    // Rb=-S2  C2  0  Rc=  0  C1 +S1   Rd=-S0  C0  0
+    //     0   0   1       0 -S1  C1       0   0   1
+    // This form is taken from Wolfram Research's Geometry>
+    // Transformations>Rotations web page (also should be
+    // found in their book).
+    // Inputs:
+    //   Double_t ang[3] The three Euler Angles Phi, Theta, Psi
+    // Outputs:
+    //   none
+    // Return:
+    //   none
+    Double_t s0,s1,s2,c0,c1,c2;
 
+    s0 = TMath::Sin(ang[0]); c0 = TMath::Cos(ang[0]);
+    s1 = TMath::Sin(ang[1]); c1 = TMath::Cos(ang[1]);
+    s2 = TMath::Sin(ang[2]); c2 = TMath::Cos(ang[2]);
+    fm[0][0] = +c2*c0-c1*s0*s2;  // fr[0]
+    fm[0][1] = +c2*s0+c1*c0*s2;  // fr[1]
+    fm[0][2] = +s2*s1;           // fr[2]
+    fm[1][0] = -s2*c0-c1*s0*c2;  // fr[3]
+    fm[1][1] = -s2*s0+c1*c0*c2;  // fr[4]
+    fm[1][2] = +c2*s1;           // fr[5]
+    fm[2][0] = s1*s0;            // fr[6]
+    fm[2][1] = -s1*c0;           // fr[7]
+    fm[2][2] = +c1;              // fr[8]
+    AngleFromMatrix();
+    return ;
+}
 //----------------------------------------------------------------------
 void AliITSgeomMatrix::GtoLPosition(const Double_t g0[3],Double_t l[3]) const {
     // Returns the local coordinates given the global coordinates [cm].
@@ -439,16 +479,16 @@ void AliITSgeomMatrix::GtoLPosition(const Double_t g0[3],Double_t l[3]) const {
     //                  detector coordiante system
     // Return:
     //   none
-       Int_t    i,j;
-       Double_t g[3];
+    Int_t    i,j;
+    Double_t g[3];
 
-       for(i=0;i<3;i++) g[i] = g0[i] - ftran[i];
-       for(i=0;i<3;i++){
-               l[i] = 0.0;
-               for(j=0;j<3;j++) l[i] += fm[i][j]*g[j];
-               // g = R l + translation
-       } // end for i
-       return;
+    for(i=0;i<3;i++) g[i] = g0[i] - ftran[i];
+    for(i=0;i<3;i++){
+        l[i] = 0.0;
+        for(j=0;j<3;j++) l[i] += fm[i][j]*g[j];
+        // g = R l + translation
+    } // end for i
+    return;
 }
 //----------------------------------------------------------------------
 void AliITSgeomMatrix::LtoGPosition(const Double_t l[3],Double_t g[3]) const {
@@ -461,15 +501,15 @@ void AliITSgeomMatrix::LtoGPosition(const Double_t l[3],Double_t g[3]) const {
     //                   Global coordinate system
     // Return:
     //   none.
-       Int_t    i,j;
+    Int_t    i,j;
 
-       for(i=0;i<3;i++){
-               g[i] = 0.0;
-               for(j=0;j<3;j++) g[i] += fm[j][i]*l[j];
-               g[i] += ftran[i];
-               // g = R^t l + translation
-       } // end for i
-       return;
+    for(i=0;i<3;i++){
+        g[i] = 0.0;
+        for(j=0;j<3;j++) g[i] += fm[j][i]*l[j];
+        g[i] += ftran[i];
+        // g = R^t l + translation
+    } // end for i
+    return;
 }
 //----------------------------------------------------------------------
 void AliITSgeomMatrix::GtoLMomentum(const Double_t g[3],Double_t l[3]) const{
@@ -484,14 +524,14 @@ void AliITSgeomMatrix::GtoLMomentum(const Double_t g[3],Double_t l[3]) const{
     //                 local coordinate system
     // Return:
     //   none.
-       Int_t    i,j;
+    Int_t    i,j;
 
-       for(i=0;i<3;i++){
-               l[i] = 0.0;
-               for(j=0;j<3;j++) l[i] += fm[i][j]*g[j];
-               // g = R l
-       } // end for i
-       return;
+    for(i=0;i<3;i++){
+        l[i] = 0.0;
+        for(j=0;j<3;j++) l[i] += fm[i][j]*g[j];
+        // g = R l
+    } // end for i
+    return;
 }
 //----------------------------------------------------------------------
 void AliITSgeomMatrix::LtoGMomentum(const Double_t l[3],Double_t g[3]) const {
@@ -506,14 +546,14 @@ void AliITSgeomMatrix::LtoGMomentum(const Double_t l[3],Double_t g[3]) const {
     //                 coordinate system
     // Return:
     //   none.
-       Int_t    i,j;
+    Int_t    i,j;
 
-       for(i=0;i<3;i++){
-               g[i] = 0.0;
-               for(j=0;j<3;j++) g[i] += fm[j][i]*l[j];
-               // g = R^t l
-       } // end for i
-       return;
+    for(i=0;i<3;i++){
+        g[i] = 0.0;
+        for(j=0;j<3;j++) g[i] += fm[j][i]*l[j];
+        // g = R^t l
+    } // end for i
+    return;
 }
 //----------------------------------------------------------------------
 void AliITSgeomMatrix::GtoLPositionError(const Double_t g[3][3],
@@ -530,15 +570,15 @@ void AliITSgeomMatrix::GtoLPositionError(const Double_t g[3][3],
     //                    local coordinate system
     // Return:
     //   none.
-       Int_t    i,j,k,m;
+    Int_t    i,j,k,m;
 
-       for(i=0;i<3;i++)for(m=0;m<3;m++){
-           l[i][m] = 0.0;
-           for(j=0;j<3;j++)for(k=0;k<3;k++)
-               l[i][m] += fm[j][i]*g[j][k]*fm[k][m];
-       } // end for i,m
-           // g = R^t l R
-       return;
+    for(i=0;i<3;i++)for(m=0;m<3;m++){
+        l[i][m] = 0.0;
+        for(j=0;j<3;j++)for(k=0;k<3;k++)
+            l[i][m] += fm[j][i]*g[j][k]*fm[k][m];
+    } // end for i,m
+    // g = R^t l R
+    return;
 }
 //----------------------------------------------------------------------
 void AliITSgeomMatrix::LtoGPositionError(const Double_t l[3][3],
@@ -554,15 +594,15 @@ void AliITSgeomMatrix::LtoGPositionError(const Double_t l[3][3],
     //                    coordinate system
     // Return:
     //   none.
-       Int_t    i,j,k,m;
+    Int_t    i,j,k,m;
 
-       for(i=0;i<3;i++)for(m=0;m<3;m++){
-           g[i][m] = 0.0;
-           for(j=0;j<3;j++)for(k=0;k<3;k++)
-               g[i][m] += fm[i][j]*l[j][k]*fm[m][k];
-       } // end for i,m
-           // g = R l R^t
-       return;
+    for(i=0;i<3;i++)for(m=0;m<3;m++){
+        g[i][m] = 0.0;
+        for(j=0;j<3;j++)for(k=0;k<3;k++)
+            g[i][m] += fm[i][j]*l[j][k]*fm[m][k];
+    } // end for i,m
+    // g = R l R^t
+    return;
 }
 //----------------------------------------------------------------------
 void AliITSgeomMatrix::GtoLPositionTracking(const Double_t g[3],
@@ -733,22 +773,22 @@ void AliITSgeomMatrix::GtoLPositionErrorTracking(const Double_t g[3][3],
     //   Double_t l[3][3] the error matrix represented in the detector 
     //                    local coordinate system
     // Return:
-       Int_t    i,j,k,m;
-       Double_t rt[3][3];
-       Double_t a0[3][3] = {{0.,+1.,0.},{-1.,0.,0.},{0.,0.,+1.}};
-       Double_t a1[3][3] = {{0.,-1.,0.},{+1.,0.,0.},{0.,0.,+1.}};
+    Int_t    i,j,k,m;
+    Double_t rt[3][3];
+    Double_t a0[3][3] = {{0.,+1.,0.},{-1.,0.,0.},{0.,0.,+1.}};
+    Double_t a1[3][3] = {{0.,-1.,0.},{+1.,0.,0.},{0.,0.,+1.}};
 
-       if(fid[0]==1) for(i=0;i<3;i++)for(j=0;j<3;j++)for(k=0;k<3;k++)
-           rt[i][k] = a0[i][j]*fm[j][k];
-       else for(i=0;i<3;i++)for(j=0;j<3;j++)for(k=0;k<3;k++)
-           rt[i][k] = a1[i][j]*fm[j][k];
-       for(i=0;i<3;i++)for(m=0;m<3;m++){
-           l[i][m] = 0.0;
-           for(j=0;j<3;j++)for(k=0;k<3;k++)
-               l[i][m] += rt[j][i]*g[j][k]*rt[k][m];
-       } // end for i,m
-           // g = R^t l R
-       return;
+    if(fid[0]==1) for(i=0;i<3;i++)for(j=0;j<3;j++)for(k=0;k<3;k++)
+        rt[i][k] = a0[i][j]*fm[j][k];
+    else for(i=0;i<3;i++)for(j=0;j<3;j++)for(k=0;k<3;k++)
+        rt[i][k] = a1[i][j]*fm[j][k];
+    for(i=0;i<3;i++)for(m=0;m<3;m++){
+        l[i][m] = 0.0;
+        for(j=0;j<3;j++)for(k=0;k<3;k++)
+            l[i][m] += rt[j][i]*g[j][k]*rt[k][m];
+    } // end for i,m
+    // g = R^t l R
+    return;
 }
 //----------------------------------------------------------------------
 void AliITSgeomMatrix::LtoGPositionErrorTracking(const Double_t l[3][3],
@@ -772,22 +812,22 @@ void AliITSgeomMatrix::LtoGPositionErrorTracking(const Double_t l[3][3],
     //                    coordinate system
     // Return:
     //   none.
-       Int_t    i,j,k,m;
-       Double_t rt[3][3];
-       Double_t a0[3][3] = {{0.,+1.,0.},{-1.,0.,0.},{0.,0.,+1.}};
-       Double_t a1[3][3] = {{0.,-1.,0.},{+1.,0.,0.},{0.,0.,+1.}};
+    Int_t    i,j,k,m;
+    Double_t rt[3][3];
+    Double_t a0[3][3] = {{0.,+1.,0.},{-1.,0.,0.},{0.,0.,+1.}};
+    Double_t a1[3][3] = {{0.,-1.,0.},{+1.,0.,0.},{0.,0.,+1.}};
 
-       if(fid[0]==1) for(i=0;i<3;i++)for(j=0;j<3;j++)for(k=0;k<3;k++)
-           rt[i][k] = a0[i][j]*fm[j][k];
-       else for(i=0;i<3;i++)for(j=0;j<3;j++)for(k=0;k<3;k++)
-           rt[i][k] = a1[i][j]*fm[j][k];
-       for(i=0;i<3;i++)for(m=0;m<3;m++){
-           g[i][m] = 0.0;
-           for(j=0;j<3;j++)for(k=0;k<3;k++)
-               g[i][m] += rt[i][j]*l[j][k]*rt[m][k];
-       } // end for i,m
-           // g = R l R^t
-       return;
+    if(fid[0]==1) for(i=0;i<3;i++)for(j=0;j<3;j++)for(k=0;k<3;k++)
+        rt[i][k] = a0[i][j]*fm[j][k];
+    else for(i=0;i<3;i++)for(j=0;j<3;j++)for(k=0;k<3;k++)
+        rt[i][k] = a1[i][j]*fm[j][k];
+    for(i=0;i<3;i++)for(m=0;m<3;m++){
+        g[i][m] = 0.0;
+        for(j=0;j<3;j++)for(k=0;k<3;k++)
+            g[i][m] += rt[i][j]*l[j][k]*rt[m][k];
+    } // end for i,m
+    // g = R l R^t
+    return;
 }
 //----------------------------------------------------------------------
 void AliITSgeomMatrix::PrintTitles(ostream *os) const {
@@ -1005,22 +1045,26 @@ TNode* AliITSgeomMatrix::CreateNode(const Char_t *nodeName,
     title = nodeTitle;
     //
     mother->cd();
-    TNode *node1 = new TNode(name.Data(),title.Data(),shape,trans[0],trans[1],trans[2],rot);
+    TNode *node1 = new TNode(name.Data(),title.Data(),shape,
+                             trans[0],trans[1],trans[2],rot);
     if(axis){
         Int_t i,j;
         const Float_t kScale=0.5,kLw=0.2;
-        Float_t xchar[13][2]={{0.5*kLw,1.},{0.,0.5*kLw},{0.5-0.5*kLw,0.5},
-                              {0.,0.5*kLw},{0.5*kLw,0.},{0.5,0.5-0.5*kLw},
-                              {1-0.5*kLw,0.},{1.,0.5*kLw},{0.5+0.5*kLw,0.5},
-                              {1.,1.-0.5*kLw},{1.-0.5*kLw,1.},{0.5,0.5+0.5*kLw},
-                              {0.5*kLw,1.}};
-        Float_t ychar[10][2]={{.5-0.5*kLw,0.},{.5+0.5*kLw,0.},{.5+0.5*kLw,0.5-0.5*kLw},
-                              {1.,1.-0.5*kLw},{1.-0.5*kLw,1.},{0.5+0.5*kLw,0.5},
-                              {0.5*kLw,1.}   ,{0.,1-0.5*kLw} ,{0.5-0.5*kLw,0.5},
-                              {.5-0.5*kLw,0.}};
-        Float_t zchar[11][2]={{0.,1.},{0,1.-kLw},{1.-kLw,1.-kLw},{0.,kLw}   ,{0.,0.},
-                              {1.,0.},{1.,kLw}  ,{kLw,kLw}      ,{1.,1.-kLw},{1.,1.},
-                              {0.,1.}};
+        Float_t xchar[13][2]={
+            {0.5*kLw,1.},{0.,0.5*kLw},{0.5-0.5*kLw,0.5},
+            {0.,0.5*kLw},{0.5*kLw,0.},{0.5,0.5-0.5*kLw},
+            {1-0.5*kLw,0.},{1.,0.5*kLw},{0.5+0.5*kLw,0.5},
+            {1.,1.-0.5*kLw},{1.-0.5*kLw,1.},{0.5,0.5+0.5*kLw},
+            {0.5*kLw,1.}};
+        Float_t ychar[10][2]={
+            {.5-0.5*kLw,0.},{.5+0.5*kLw,0.},{.5+0.5*kLw,0.5-0.5*kLw},
+            {1.,1.-0.5*kLw},{1.-0.5*kLw,1.},{0.5+0.5*kLw,0.5},
+            {0.5*kLw,1.}   ,{0.,1-0.5*kLw} ,{0.5-0.5*kLw,0.5},
+            {.5-0.5*kLw,0.}};
+        Float_t zchar[11][2]={
+            {0.,1.},{0,1.-kLw},{1.-kLw,1.-kLw},{0.,kLw}   ,{0.,0.},
+            {1.,0.},{1.,kLw}  ,{kLw,kLw}      ,{1.,1.-kLw},{1.,1.},
+            {0.,1.}};
         for(i=0;i<13;i++)for(j=0;j<2;j++){
             if(i<13) xchar[i][j] = kScale*xchar[i][j];
             if(i<10) ychar[i][j] = kScale*ychar[i][j];
@@ -1035,16 +1079,18 @@ TNode* AliITSgeomMatrix::CreateNode(const Char_t *nodeName,
         TXTRU *axiszl = new TXTRU("z","z","text",10,2);
         for(i=0;i<10;i++) axiszl->DefineVertex(i,zchar[i][0],zchar[i][1]);
         axiszl->DefineSection(0,-0.5*kLw);axiszl->DefineSection(1,0.5*kLw);
-        Float_t lxy[13][2]={{-0.5*kLw,-0.5*kLw},{0.8,-0.5*kLw},{0.8,-0.1},{1.0,0.0},
-                            {0.8,0.1},{0.8,0.5*kLw},{0.5*kLw,0.5*kLw},{0.5*kLw,0.8},
-                            {0.1,0.8},{0.0,1.0},{-0.1,0.8},{-0.5*kLw,0.8},
-                            {-0.5*kLw,-0.5*kLw}};
+        Float_t lxy[13][2]={
+            {-0.5*kLw,-0.5*kLw},{0.8,-0.5*kLw},{0.8,-0.1},{1.0,0.0},
+            {0.8,0.1},{0.8,0.5*kLw},{0.5*kLw,0.5*kLw},{0.5*kLw,0.8},
+            {0.1,0.8},{0.0,1.0},{-0.1,0.8},{-0.5*kLw,0.8},
+            {-0.5*kLw,-0.5*kLw}};
         TXTRU *axisxy = new TXTRU("axisxy","axisxy","text",13,2);
         for(i=0;i<13;i++) axisxy->DefineVertex(i,lxy[i][0],lxy[i][1]);
         axisxy->DefineSection(0,-0.5*kLw);axisxy->DefineSection(1,0.5*kLw);
-        Float_t lz[8][2]={{0.5*kLw,-0.5*kLw},{0.8,-0.5*kLw},{0.8,-0.1},{1.0,0.0},
-                           {0.8,0.1},{0.8,0.5*kLw},{0.5*kLw,0.5*kLw},
-                           {0.5*kLw,-0.5*kLw}};
+        Float_t lz[8][2]={
+            {0.5*kLw,-0.5*kLw},{0.8,-0.5*kLw},{0.8,-0.1},{1.0,0.0},
+            {0.8,0.1},{0.8,0.5*kLw},{0.5*kLw,0.5*kLw},
+            {0.5*kLw,-0.5*kLw}};
         TXTRU *axisz = new TXTRU("axisz","axisz","text",8,2);
         for(i=0;i<8;i++) axisz->DefineVertex(i,lz[i][0],lz[i][1]);
         axisz->DefineSection(0,-0.5*kLw);axisz->DefineSection(1,0.5*kLw);
@@ -1056,7 +1102,8 @@ TNode* AliITSgeomMatrix::CreateNode(const Char_t *nodeName,
         title = name.Append("axisxy");
         TNode *nodeaxy = new TNode(title.Data(),title.Data(),axisxy);
         title = name.Append("axisz");
-        TNode *nodeaz = new TNode(title.Data(),title.Data(),axisz,0.,0.,0.,yaxis90);
+        TNode *nodeaz = new TNode(title.Data(),title.Data(),axisz,
+                                  0.,0.,0.,yaxis90);
         TNode *textboxX0 = new TNode("textboxX0","textboxX0",axisxl,
                                     lxy[3][0],lxy[3][1],0.0);
         TNode *textboxX1 = new TNode("textboxX1","textboxX1",axisxl,
@@ -1136,8 +1183,10 @@ void AliITSgeomMatrix::MakeFigures() const {
     node0->cd();
     TNode *node1 = new TNode("NODE1","NODE1",det);
     node1->cd();
-    TNode *nodex = new TNode("NODEx","NODEx",arrow,l[0][0],l[0][1],l[0][2],xarrow);
-    TNode *nodey = new TNode("NODEy","NODEy",arrow,l[2][0],l[2][1],l[2][2],yarrow);
+    TNode *nodex = new TNode("NODEx","NODEx",arrow,
+                             l[0][0],l[0][1],l[0][2],xarrow);
+    TNode *nodey = new TNode("NODEy","NODEy",arrow,
+                             l[2][0],l[2][1],l[2][2],yarrow);
     TNode *nodez = new TNode("NODEz","NODEz",arrow,l[4][0],l[4][1],l[4][2]);
     //
     axis->Draw();
index 29ee980019b0debb5ace5d3318966c44c1d2c9d7..ebca4d5d96d928d4dde30c0badd60000542663cd 100644 (file)
@@ -18,131 +18,138 @@ class TShape;
 
 class AliITSgeomMatrix : public TObject {
  public:
-       AliITSgeomMatrix(); // Default constructor
-       // Standard constructor #1
-       AliITSgeomMatrix(Int_t idt,const Int_t id[3],
-                        const Double_t rot[3],const Double_t tran[3]);
-       // Standard constructor #2
-        AliITSgeomMatrix(Int_t idt,const Int_t id[3],
-                        Double_t matrix[3][3],const Double_t tran[3]);
-       // Standard constructor #3
-        AliITSgeomMatrix(const Double_t rotd[6]/*degrees GEANT angles*/,
-                         Int_t idt,const Int_t id[3],
-                         const Double_t tran[3]);
-       // Copy constructor
-       AliITSgeomMatrix(const AliITSgeomMatrix &source);
-       // Assignment operator
-       AliITSgeomMatrix& operator=(const AliITSgeomMatrix &source); 
-       virtual ~AliITSgeomMatrix(){}; // default constructor.
-       // Prints a line describing the output format of the function Print.
-       void PrintComment(ostream *os) const;
-       // Prints out the content of this class in ASCII format.
-       void Print(ostream *os)const;
-       // Prints out the content of this class in ASCII format but includes
-       // formating and strings that make it more humanly readable.
-       void PrintTitles(ostream *os) const;
-       // Reads in the content of this class in the format of Print
-       void Read(istream *is);
-     virtual void Print(Option_t *option="") const {
-                       TObject::Print(option);}
-     virtual Int_t Read(const char *name) {return TObject::Read(name);}
+    AliITSgeomMatrix(); // Default constructor
+    // Standard constructor #1
+    AliITSgeomMatrix(Int_t idt,const Int_t id[3],
+                     const Double_t rot[3],const Double_t tran[3]);
+    // Standard constructor #2
+    AliITSgeomMatrix(Int_t idt,const Int_t id[3],
+                     Double_t matrix[3][3],const Double_t tran[3]);
+    // Standard constructor #3
+    AliITSgeomMatrix(const Double_t rotd[6]/*degrees GEANT angles*/,
+                     Int_t idt,const Int_t id[3],
+                     const Double_t tran[3]);
+    // Copy constructor
+    AliITSgeomMatrix(const AliITSgeomMatrix &source);
+    // Assignment operator
+    AliITSgeomMatrix& operator=(const AliITSgeomMatrix &source); 
+    virtual ~AliITSgeomMatrix(){}; // default constructor.
+    // Prints a line describing the output format of the function Print.
+    void PrintComment(ostream *os) const;
+    // Prints out the content of this class in ASCII format.
+    void Print(ostream *os)const;
+    // Prints out the content of this class in ASCII format but includes
+    // formating and strings that make it more humanly readable.
+    void PrintTitles(ostream *os) const;
+    // Reads in the content of this class in the format of Print
+    void Read(istream *is);
+    virtual void Print(Option_t *option="") const {
+        TObject::Print(option);}
+    virtual Int_t Read(const char *name) {return TObject::Read(name);}
+    
+    // Returns the geometry path corresponding to this transformation
+    TString& GetPath(){return fPath;}
+    // Sets the geometry path
+    void SetPath(const Char_t *p){fPath = p;}
+    void SetPath(const TString &p){fPath = p;}
+    // Given the rotation angles [radians] it fills frot and computes
+    // the rotation matrix fm.
+    void SetAngles(const Double_t rot[3]){// [radians]
+        for(Int_t i=0;i<3;i++)frot[i] = rot[i];this->MatrixFromAngle();}
+    // Sets the translation vector and computes fCylR and fCylPhi.
+    void SetTranslation(const Double_t tran[3]);
+    // sets the rotation matrix and computes the rotation angles [radians]
+    void SetMatrix(const Double_t matrix[3][3]){ for(Int_t i=0;i<3;i++)
+        for(Int_t j=0;j<3;j++) fm[i][j]=matrix[i][j];this->AngleFromMatrix();}
+    // Sets the detector index value
+    void SetDetectorIndex(Int_t idt) {fDetectorIndex = idt;}
+    // Sets the detector layer, ladder, detector (id) values.
+    void SetIndex(const Int_t id[3]){
+        for(Int_t i=0;i<3;i++) fid[i] = id[i];}
+    // Returns the rotation angles [radians]
+    void GetAngles(Double_t rot[3]) const {// [radians]
+        for(Int_t i=0;i<3;i++)  rot[i] = frot[i];}
+    // Returns the translation vector [cm]
+    void GetTranslation(Double_t tran[3]) const {
+        for(Int_t i=0;i<3;i++) tran[i] = ftran[i];}
+    // Returns the translation vector in cylindrical
+    // coordinates [cm,radians]
+    void GetTranslationCylinderical (Double_t tran[3]) const {
+        tran[0] = fCylR;
+        tran[1] = fCylPhi;
+        tran[2] = ftran[2];}
+    // Returns the values of the rotation matrix
+    void GetMatrix(Double_t matrix[3][3]) const {for(Int_t i=0;i<3;i++)
+        for(Int_t j=0;j<3;j++) matrix[i][j] = fm[i][j];}
+    // Returns the detector index value.
+    Int_t GetDetectorIndex() const {return fDetectorIndex;}
+    // returns the modules index layer, ladder, detector
+    void  GetIndex(Int_t id[3]) const {for(Int_t i=0;i<3;i++) id[i] = fid[i];}
+    // return the x,y,z components (global) of the normalized normal
+    // vector which helps to define the plane the detector is a part of
+    void GetGlobalNormal(Double_t &nx,Double_t &ny,Double_t &nz)const{
+        Double_t ln[3]={0.0,1.0,0.0},gn[3];LtoGMomentum(ln,gn);
+        nx = gn[0];ny=gn[1];nz=gn[2];return;}
+    // Sets the rotation matrix based on the 6 GEANT rotation
+    // angles [radian]
+    void  MatrixFromSixAngles(const Double_t *ang);
+    // Returns the 6 GEANT rotation angles [radians] from the
+    // existing rotation matrix.
+    void  SixAnglesFromMatrix(Double_t *ang)const;
+    // Set rotation using the Euler's Chi-convention
+    void SetEulerAnglesChi(const Double_t ang[3]);
 
-     // Returns the geometry path corresponding to this transformation
-     TString& GetPath(){return fPath;}
-     // Sets the geometry path
-     void SetPath(const Char_t *p){fPath = p;}
-     void SetPath(const TString &p){fPath = p;}
-       // Given the rotation angles [radians] it fills frot and computes
-       // the rotation matrix fm.
-       void SetAngles(const Double_t rot[3]){// [radians]
-              for(Int_t i=0;i<3;i++)frot[i] = rot[i];this->MatrixFromAngle();}
-       // Sets the translation vector and computes fCylR and fCylPhi.
-       void SetTranslation(const Double_t tran[3]);
-       // sets the rotation matrix and computes the rotation angles [radians]
-       void SetMatrix(const Double_t matrix[3][3]){ for(Int_t i=0;i<3;i++)
-        for(Int_t j=0;j<3;j++) fm[i][j]=matrix[i][j];this->AngleFromMatrix();}
-       // Sets the detector index value
-       void SetDetectorIndex(Int_t idt) {fDetectorIndex = idt;}
-       // Sets the detector layer, ladder, detector (id) values.
-       void SetIndex(const Int_t id[3]){
-                          for(Int_t i=0;i<3;i++) fid[i] = id[i];}
-       // Returns the rotation angles [radians]
-       void GetAngles(Double_t rot[3]) const {// [radians]
-                          for(Int_t i=0;i<3;i++)  rot[i] = frot[i];}
-       // Returns the translation vector [cm]
-       void GetTranslation(Double_t tran[3]) const {
-                           for(Int_t i=0;i<3;i++) tran[i] = ftran[i];}
-       // Returns the translation vector in cylindrical
-       // coordinates [cm,radians]
-       void GetTranslationCylinderical (Double_t tran[3]) const {
-                           tran[0] = fCylR;
-                           tran[1] = fCylPhi;
-                           tran[2] = ftran[2];}
-       // Returns the values of the rotation matrix
-       void GetMatrix(Double_t matrix[3][3]) const {for(Int_t i=0;i<3;i++)
-                        for(Int_t j=0;j<3;j++) matrix[i][j] = fm[i][j];}
-       // Returns the detector index value.
-       Int_t GetDetectorIndex() const {return fDetectorIndex;}
-       // returns the modules index layer, ladder, detector
-       void  GetIndex(Int_t id[3]) const {for(Int_t i=0;i<3;i++) id[i] = fid[i];}
-       // Sets the rotation matrix based on the 6 GEANT rotation
-       // angles [radian]
-       void  MatrixFromSixAngles(const Double_t *ang);
-       // Returns the 6 GEANT rotation angles [radians] from the
-       // existing rotation matrix.
-       void  SixAnglesFromMatrix(Double_t *ang)const;
-
-       // Given a position in Cartesian ALICE global coordinates [cm]
-       // returns the position in Cartesian detector/module local
-       //coordinates [cm]
-       void GtoLPosition(const Double_t g[3],Double_t l[3]) const;
-       // Given a position in Cartesian detector/module local coordinates [cm]
-       // returns the position in Cartesian ALICE global
-       //coordinates [cm]
-       void LtoGPosition(const Double_t l[3],Double_t g[3]) const;
-       // Given a momentum in Cartesian ALICE global coordinates
-       // returns the momentum in Cartesian detector/module local
-       //coordinates
-       void GtoLMomentum(const Double_t g[3],Double_t l[3]) const;
-       // Given a momentum in Cartesian detector/module local coordinates 
-       // returns the momentum in Cartesian ALICE global coordinates
-       void LtoGMomentum(const Double_t l[3],Double_t g[3]) const;
-       // given a position error matrix in ALICE Cartesian global
-       // coordinates [cm] returns a position error matrix in detector/
-       // module local Cartesian local coordinates [cm]
-       void GtoLPositionError(const Double_t g[3][3],Double_t l[3][3]) const;
-       // given a position error matrix in detector/module Cartesian local
-       // coordinates [cm] returns a position error matrix in ALICE
-       // Cartesian global coordinates [cm]
-       void LtoGPositionError(const Double_t l[3][3],Double_t g[3][3]) const;
-       // Tracking Related Routines
-       void GtoLPositionTracking(const Double_t g[3],Double_t l[3]) const;
-       // Given a position in Cartesian Tracking global coordinates [cm]
-       // returns the position in Cartesian detector/module local
-       // coordinates [cm]
-       void LtoGPositionTracking(const Double_t l[3],Double_t g[3]) const;
-       // Given a position in Cartesian detector/module local coordinates [cm]
-       // returns the position in Cartesian Tracking global
-       //coordinates [cm]
-       void GtoLMomentumTracking(const Double_t g[3],Double_t l[3]) const;
-       // Given a momentum in Cartesian detector/module local coordinates 
-       // returns the momentum in Cartesian Tracking global coordinates
-       void LtoGMomentumTracking(const Double_t l[3],Double_t g[3]) const;
-       // given a position error matrix in Tracking Cartesian global
-       // coordinates [cm] returns a position error matrix in detector/
-       // module local Cartesian local coordinates [cm]
-       void GtoLPositionErrorTracking(const Double_t g[3][3],
-                                      Double_t l[3][3]) const;
-       // given a position error matrix in detector/module Cartesian local
-       // coordinates [cm] returns a position error matrix in Tracking
-       // Cartesian global coordinates [cm]
-       void LtoGPositionErrorTracking(const Double_t l[3][3],
-                                      Double_t g[3][3]) const;
-       // Computes the distance squared [cm^2] between a point t[3] and
-       // this module/detector
-       Double_t Distance2(const Double_t t[3]) const {Double_t d=0.0,q;
-                 for(Int_t i=0;i<3;i++){q = t[i]-ftran[i]; d += q*q;}
-                 return d;}
+    // Given a position in Cartesian ALICE global coordinates [cm]
+    // returns the position in Cartesian detector/module local
+    //coordinates [cm]
+    void GtoLPosition(const Double_t g[3],Double_t l[3]) const;
+    // Given a position in Cartesian detector/module local coordinates [cm]
+    // returns the position in Cartesian ALICE global
+    //coordinates [cm]
+    void LtoGPosition(const Double_t l[3],Double_t g[3]) const;
+    // Given a momentum in Cartesian ALICE global coordinates
+    // returns the momentum in Cartesian detector/module local
+    //coordinates
+    void GtoLMomentum(const Double_t g[3],Double_t l[3]) const;
+    // Given a momentum in Cartesian detector/module local coordinates 
+    // returns the momentum in Cartesian ALICE global coordinates
+    void LtoGMomentum(const Double_t l[3],Double_t g[3]) const;
+    // given a position error matrix in ALICE Cartesian global
+    // coordinates [cm] returns a position error matrix in detector/
+    // module local Cartesian local coordinates [cm]
+    void GtoLPositionError(const Double_t g[3][3],Double_t l[3][3]) const;
+    // given a position error matrix in detector/module Cartesian local
+    // coordinates [cm] returns a position error matrix in ALICE
+    // Cartesian global coordinates [cm]
+    void LtoGPositionError(const Double_t l[3][3],Double_t g[3][3]) const;
+    // Tracking Related Routines
+    void GtoLPositionTracking(const Double_t g[3],Double_t l[3]) const;
+    // Given a position in Cartesian Tracking global coordinates [cm]
+    // returns the position in Cartesian detector/module local
+    // coordinates [cm]
+    void LtoGPositionTracking(const Double_t l[3],Double_t g[3]) const;
+    // Given a position in Cartesian detector/module local coordinates [cm]
+    // returns the position in Cartesian Tracking global
+    //coordinates [cm]
+    void GtoLMomentumTracking(const Double_t g[3],Double_t l[3]) const;
+    // Given a momentum in Cartesian detector/module local coordinates 
+    // returns the momentum in Cartesian Tracking global coordinates
+    void LtoGMomentumTracking(const Double_t l[3],Double_t g[3]) const;
+    // given a position error matrix in Tracking Cartesian global
+    // coordinates [cm] returns a position error matrix in detector/
+    // module local Cartesian local coordinates [cm]
+    void GtoLPositionErrorTracking(const Double_t g[3][3],
+                                   Double_t l[3][3]) const;
+    // given a position error matrix in detector/module Cartesian local
+    // coordinates [cm] returns a position error matrix in Tracking
+    // Cartesian global coordinates [cm]
+    void LtoGPositionErrorTracking(const Double_t l[3][3],
+                                   Double_t g[3][3]) const;
+    // Computes the distance squared [cm^2] between a point t[3] and
+    // this module/detector
+    Double_t Distance2(const Double_t t[3]) const {Double_t d=0.0,q;
+    for(Int_t i=0;i<3;i++){q = t[i]-ftran[i]; d += q*q;}
+    return d;}
      //
      // Documentation related Class
      TPolyLine3D* CreateLocalAxis() const;
@@ -152,25 +159,25 @@ class AliITSgeomMatrix : public TObject {
      void MakeFigures() const;
      //
  private: // private functions
-       // Given the rotation matrix fm it fills the rotation angles frot
-       void MatrixFromAngle();
-       // Given the rotation angles frot it fills the rotation matrix fm
-       void AngleFromMatrix();
+     // Given the rotation matrix fm it fills the rotation angles frot
+     void MatrixFromAngle();
+     // Given the rotation angles frot it fills the rotation matrix fm
+     void AngleFromMatrix();
  private: // Data members.
-       Int_t    fDetectorIndex; // Detector type index (like fShapeIndex was)
-       Int_t    fid[3];         // layer, ladder, detector numbers.
-       Double_t frot[3];        //! vector of rotations about x,y,z [radians].
-       Double_t ftran[3];       // Translation vector of module x,y,z.
-       Double_t fCylR,fCylPhi;  //! Translation vector in Cylindrical coord.
-       Double_t fm[3][3];       // Rotation matrix based on frot.
-       TString  fPath;          // Path within Geometry to this volume
-
-       // Note, fCylR and fCylPhi are added as data members because it costs
-       // about a factor of 10 to compute them over looking them up. Since
-       // they are used in some tracking algorithms this can be a large cost
-       // in computing time. They are not written out but computed.
-
-       ClassDef(AliITSgeomMatrix,2) // Matrix class used by AliITSgeom.
+     Int_t    fDetectorIndex; // Detector type index (like fShapeIndex was)
+     Int_t    fid[3];         // layer, ladder, detector numbers.
+     Double_t frot[3];        //! vector of rotations about x,y,z [radians].
+     Double_t ftran[3];       // Translation vector of module x,y,z.
+     Double_t fCylR,fCylPhi;  //! Translation vector in Cylindrical coord.
+     Double_t fm[3][3];       // Rotation matrix based on frot.
+     TString  fPath;          // Path within Geometry to this volume
+     
+     // Note, fCylR and fCylPhi are added as data members because it costs
+     // about a factor of 10 to compute them over looking them up. Since
+     // they are used in some tracking algorithms this can be a large cost
+     // in computing time. They are not written out but computed.
+     
+     ClassDef(AliITSgeomMatrix,2) // Matrix class used by AliITSgeom.
 };
 // Input and output function for standard C++ input/output.
 ostream &operator<<(ostream &os,AliITSgeomMatrix &source);
index dcb73d141e8c3310cf3232b60fac72eee573efff..a40ae04ae8b82cf6b7368c9552d3a6b80ee4a214 100644 (file)
@@ -17,7 +17,8 @@
 
 #include <Riostream.h>
 
-#include<TLorentzVector.h>
+#include <TLorentzVector.h>
+#include <TParticle.h>
 
 #include "AliRun.h"
 #include "AliITS.h"
@@ -190,20 +191,19 @@ ClassImp(AliITShit)
 ////////////////////////////////////////////////////////////////////////
 //_____________________________________________________________________________
 AliITShit::AliITShit():AliHit(),
-fStatus(0),
-fLayer(0),
-fLadder(0),
-fDet(0),
-fPx(0.0),
-fPy(0.0),
-fPz(0.0),
-fDestep(0.0),
-fTof(0.0),
-fStatus0(0),
-fx0(0.0),
-fy0(0.0),
-fz0(0.0),
-ft0(0.0){
+fStatus(0), // Track Status
+fModule(0),  // Module number 
+fPx(0.0),     // PX of particle at the point of the hit
+fPy(0.0),     // PY of particle at the point of the hit
+fPz(0.0),     // PZ of particle at the point of the hit
+fDestep(0.0), // Energy deposited in the current step
+fTof(0.0),    // Time of flight at the point of the hit
+fStatus0(0),// Track Status of Starting point
+fx0(0.0),     // Starting point of this step
+fy0(0.0),     // Starting point of this step
+fz0(0.0),     // Starting point of this step
+ft0(0.0)     // Starting point of this step
+{
     // Default Constructor
     // Zero data member just to be safe.
     // Intputs:
@@ -214,84 +214,85 @@ ft0(0.0){
     //    A default created AliITShit class.
 
 }
+//----------------------------------------------------------------------
 AliITShit::AliITShit(Int_t shunt,Int_t track,Int_t *vol,Float_t edep,
-                    Float_t tof,TLorentzVector &x,TLorentzVector &x0,
-                    TLorentzVector &p) : AliHit(shunt, track),
-fStatus(vol[3]),
-fLayer(vol[0]),
-fLadder(vol[2]),
-fDet(vol[1]),
-fPx(p.Px()),
-fPy(p.Py()),
-fPz(p.Pz()),
-fDestep(edep),
-fTof(tof),
-fStatus0(vol[4]),
-fx0(x0.X()),
-fy0(x0.Y()),
-fz0(x0.Z()),
-ft0(x0.T()){
-////////////////////////////////////////////////////////////////////////
-// Create ITS hit
-//     The creator of the AliITShit class. The variables shunt and
-// track are passed to the creator of the AliHit class. See the AliHit
-// class for a full description. In the units of the Monte Carlo
-////////////////////////////////////////////////////////////////////////
-    // Intputs:
+                     Float_t tof,TLorentzVector &x,TLorentzVector &x0,
+                     TLorentzVector &p) :
+AliHit(shunt, track), // AliHit
+fStatus(vol[3]), // Track Status
+fModule(vol[0]),  // Module number 
+fPx(p.Px()),     // PX of particle at the point of the hit
+fPy(p.Py()),     // PY of particle at the point of the hit
+fPz(p.Pz()),     // PZ of particle at the point of the hit
+fDestep(edep), // Energy deposited in the current step
+fTof(tof),    // Time of flight at the point of the hit
+fStatus0(vol[4]),// Track Status of Starting point
+fx0(x0.X()),     // Starting point of this step
+fy0(x0.Y()),     // Starting point of this step
+fz0(x0.Z()),     // Starting point of this step
+ft0(x0.T())     // Starting point of this step
+{
+    // Create ITS hit
+    //     The creator of the AliITShit class. The variables shunt and
+    // track are passed to the creator of the AliHit class. See the AliHit
+    // class for a full description. In the units of the Monte Carlo
+    // Inputs:
     //    Int_t shunt   See AliHit
     //    Int_t track   Track number, see AliHit
     //    Int_t *vol     Array of integer hit data,
-    //                     vol[0] Layer where the hit is, 1-6 typicaly
-    //                     vol[1] Ladder where the hit is.
-    //                     vol[2] Detector number where the hit is
+    //                     vol[0] module
+    //                     vol[1] not used
+    //                     vol[2] not used
     //                     vol[3] Set of status bits
     //                     vol[4] Set of status bits at start
+    //    Float_t edep       The energy deposited GeV during the transport
+    //                       of this step
+    //    Float_t tof        The time of flight of this particle at this step
+    //    TLorenzVector &x   The Global position of this step [cm]
+    //    TLorenzVector &x0  The Global position of where this step 
+    //                       started from [cm]
+    //    TLorenzVector &p   The Global momentum of the particle at this
+    //                       step [GeV/c]
     // Outputs:
     //    none.
     // Return:
     //    A default created AliITShit class.
 
-
-
-    fX          = x.X();   // Track X global position
-    fY          = x.Y();   // Track Y global position
-    fZ          = x.Z();   // Track Z global position
+    SetPosition(x);
 }
 //______________________________________________________________________
 AliITShit::AliITShit(Int_t shunt, Int_t track, Int_t *vol, Float_t *hits):
-    AliHit(shunt, track),
-fStatus(vol[3]),
-fLayer(vol[0]),
-fLadder(vol[2]),
-fDet(vol[1]),
-fPx(hits[3]),
-fPy(hits[4]),
-fPz(hits[5]),
-fDestep(hits[6]),
-fTof(hits[7]),
-fStatus0(0),
-fx0(0.0),
-fy0(0.0),
-fz0(0.0),
-ft0(0.0){
-////////////////////////////////////////////////////////////////////////
-// Create ITS hit
-//     The creator of the AliITShit class. The variables shunt and
-// track are passed to the creator of the AliHit class. See the AliHit
-// class for a full description. the integer array *vol contains, in order,
-// fLayer = vol[0], fDet = vol[1], fLadder = vol[2], fStatus = vol[3].
-// The array *hits contains, in order, fX = hits[0], fY = hits[1],
-// fZ = hits[2], fPx = hits[3], fPy = hits[4], fPz = hits[5],
-// fDestep = hits[6], and fTof = hits[7]. In the units of the Monte Carlo
-////////////////////////////////////////////////////////////////////////
+    AliHit(shunt, track), // AliHit
+fStatus(vol[3]), // Track Status
+fModule(vol[0]),  // Module number 
+fPx(hits[3]),     // PX of particle at the point of the hit
+fPy(hits[4]),     // PY of particle at the point of the hit
+fPz(hits[5]),     // PZ of particle at the point of the hit
+fDestep(hits[6]), // Energy deposited in the current step
+fTof(hits[7]),    // Time of flight at the point of the hit
+fStatus0(vol[4]),// Track Status of Starting point
+fx0(hits[8]),     // Starting point of this step
+fy0(hits[9]),     // Starting point of this step
+fz0(hits[10]),     // Starting point of this step
+ft0(hits[11])     // Starting point of this step
+{
+    // Create ITS hit
+    //     The creator of the AliITShit class. The variables shunt and
+    // track are passed to the creator of the AliHit class. See the AliHit
+    // class for a full description. the integer array *vol contains, in order,
+    // fLayer = vol[0], fDet = vol[1], fLadder = vol[2], fStatus = vol[3].
+    // The array *hits contains, in order, fX = hits[0], fY = hits[1],
+    // fZ = hits[2], fPx = hits[3], fPy = hits[4], fPz = hits[5],
+    // fDestep = hits[6], and fTof = hits[7]. In the units of the Monte Carlo
     // Intputs:
     //    Int_t shunt   See AliHit
     //    Int_t track   Track number, see AliHit
     //    Int_t *vol     Array of integer hit data,
-    //                     vol[0] Layer where the hit is, 1-6 typicaly
-    //                     vol[1] Ladder where the hit is.
-    //                     vol[2] Detector number where the hit is
+    //                     vol[0] module number
+    //                     vol[1] not used
+    //                     vol[2] not used
     //                     vol[3] Set of status bits
+    //                     vol[4] Set of status bits at start
     //    Float_t *hits   Array of hit information
     //                     hits[0] X global position of this hit
     //                     hits[1] Y global position of this hit
@@ -301,46 +302,123 @@ ft0(0.0){
     //                     hits[5] Pz global position of this hit
     //                     hits[6] Energy deposited by this step
     //                     hits[7] Time of flight of this particle at this step
+    //                     hits[8] X0 global position of start of step
+    //                     hits[9] Y0 global position of start of step
+    //                     hits[10] Z0 global position of start of step
+    //                     hits[11] Time of flight of this particle before step
     // Outputs:
     //    none.
     // Return:
     //    A standard created AliITShit class.
-  fX          = hits[0];  // Track X global position
-  fY          = hits[1];  // Track Y global position
-  fZ          = hits[2];  // Track Z global position
+
+    fX          = hits[0];  // Track X global position
+    fY          = hits[1];  // Track Y global position
+    fZ          = hits[2];  // Track Z global position
 }
 //______________________________________________________________________
-void AliITShit::GetPositionL(Float_t &x,Float_t &y,Float_t &z){
-////////////////////////////////////////////////////////////////////////
-//     Returns the position of this hit in the local coordinates of this
-// module, and in the units of the Monte Carlo.
-////////////////////////////////////////////////////////////////////////
-    AliITSgeom *gm = ((AliITS*)gAlice->GetDetector("ITS"))->GetITSgeom();
-    Float_t g[3],l[3];
+AliITShit::AliITShit(const AliITShit &h):
+AliHit(h), // AliHit
+fStatus(h.fStatus), // Track Status
+fModule(h.fModule),  // Module number 
+fPx(h.fPx),     // PX of particle at the point of the hit
+fPy(h.fPy),     // PY of particle at the point of the hit
+fPz(h.fPz),     // PZ of particle at the point of the hit
+fDestep(h.fDestep), // Energy deposited in the current step
+fTof(h.fTof),    // Time of flight at the point of the hit
+fStatus0(h.fStatus0),// Track Status of Starting point
+fx0(h.fx0),     // Starting point of this step
+fy0(h.fy0),     // Starting point of this step
+fz0(h.fz0),     // Starting point of this step
+ft0(h.ft0)     // Starting point of this step
+{
+    // The standard copy constructor
+    // Inputs:
+    //   AliITShit   &h the sourse of this copy
+    // Outputs:
+    //   none.
+    // Return:
+    //  A copy of the sourse hit h
 
-    g[0] = fX;
-    g[1] = fY;
-    g[2] = fZ;
-    if(gm) {
-      gm->GtoL(fLayer,fLadder,fDet,g,l);
-      x = l[0];
-      y = l[1];
-      z = l[2];
-    } else {
-      Error("AliITShit","NULL pointer to the geometry! return smth else",gm);
-      // AliITSv7 - SDD case
-      x=fX;
-      y=fY;
-      z=fZ;
-    }
+    //Info("CopyConstructor","Coping hit");
+
+    if(this == &h) return;
     return;
 }
 //______________________________________________________________________
+AliITShit& AliITShit::operator=(const AliITShit &h){
+    // The standard = operator
+    // Inputs:
+    //   AliITShit   &h the sourse of this copy
+    // Outputs:
+    //   none.
+    // Return:
+    //  A copy of the sourse hit h
+
+    if(this == &h) return *this;
+    this->fStatus  = h.fStatus;
+    this->fModule  = h.fModule;
+    this->fPx      = h.fPx;
+    this->fPy      = h.fPy;
+    this->fPz      = h.fPz;
+    this->fDestep  = h.fDestep;
+    this->fTof     = h.fTof;
+    this->fStatus0 = h.fStatus0;
+    this->fx0      = h.fx0;
+    this->fy0      = h.fy0;
+    this->fz0      = h.fz0;
+    this->ft0      = h.ft0;
+    return *this;
+}
+//______________________________________________________________________
+void AliITShit::SetShunt(Int_t shunt){
+    // Sets track flag based on shunt value. Code copied from
+    // AliHit standar constructor.
+    // Inputs:
+    //   Int_t shunt    A flag to indecate what to do with track numbers
+    // Outputs:
+    //   none.
+    // Return:
+    //   none.
+    Int_t primary,track,current,parent;
+    TParticle *part;
+
+    track = fTrack;
+    if(shunt == 1) {
+        primary = gAlice->GetMCApp()->GetPrimary(track);
+        gAlice->GetMCApp()->Particle(primary)->SetBit(kKeepBit);
+        fTrack=primary;
+    }else if (shunt == 2) {
+        // the "primary" particle associated to the hit is
+        // the last track that has been flagged in the StepManager
+        // used by PHOS to associate the hit with the decay gamma
+        // rather than with the original pi0
+        parent=track;
+        while (1) {
+            current=parent;
+            part = gAlice->GetMCApp()->Particle(current);
+            parent=part->GetFirstMother();
+            if(parent<0 || part->TestBit(kKeepBit))
+                break;
+        }
+        fTrack=current;
+    }else {
+        fTrack=track;
+        gAlice->GetMCApp()->FlagTrack(fTrack);
+    } // end if shunt
+}
+//______________________________________________________________________
 void AliITShit::GetPositionL(Float_t &x,Float_t &y,Float_t &z,Float_t &tof){
-////////////////////////////////////////////////////////////////////////
-//     Returns the position and time of flight of this hit in the local
-// coordinates of this module, and in the units of the Monte Carlo.
-////////////////////////////////////////////////////////////////////////
+    //     Returns the position and time of flight of this hit in the local
+    // coordinates of this module, and in the units of the Monte Carlo.
+    // Inputs:
+    //   none.
+    // Outputs:
+    //   Float_t x   Global position of this hit [cm]
+    //   Float_t y   Global position of this hit [cm]
+    //   Float_t z   Global poistion of this hit [cm]
+    //   Float_t tof Time of flight of particle at this hit
+    // Return:
+    //   none.
     AliITSgeom *gm = ((AliITS*)gAlice->GetDetector("ITS"))->GetITSgeom();
     Float_t g[3],l[3];
 
@@ -348,27 +426,35 @@ void AliITShit::GetPositionL(Float_t &x,Float_t &y,Float_t &z,Float_t &tof){
     g[1] = fY;
     g[2] = fZ;
     if(gm) {
-      gm->GtoL(fLayer,fLadder,fDet,g,l);
-      x = l[0];
-      y = l[1];
-      z = l[2];
+        gm->GtoL(fModule,g,l);
+        x = l[0];
+        y = l[1];
+        z = l[2];
     } else {
-      Error("AliITShit","NULL pointer to the geometry! return smth else",gm);
-      // AliITSv7 - SDD case
-      x=fX;
-      y=fY;
-      z=fZ;
-    }
+        Error("AliITShit","NULL pointer to the geometry! return smth else",gm);
+        // AliITSv7 - SDD case
+        x=fX;
+        y=fY;
+        z=fZ;
+    } // end if
     tof = fTof;
     return;
 }
 //______________________________________________________________________
 void AliITShit::GetPositionL0(Double_t &x,Double_t &y,Double_t &z,
-                             Double_t &tof){
-////////////////////////////////////////////////////////////////////////
-//     Returns the initial position and time of flight of this hit in the local
-// coordinates of this module, and in the units of the Monte Carlo.
-////////////////////////////////////////////////////////////////////////
+                              Double_t &tof){
+    //     Returns the initial position and time of flight of this hit 
+    // in the local coordinates of this module, and in the units of the 
+    // Monte Carlo.
+    // Inputs:
+    //   none.
+    // Outputs:
+    //   Double_t x   Global position of this hit [cm]
+    //   Double_t y   Global position of this hit [cm]
+    //   Double_t z   Global poistion of this hit [cm]
+    //   Double_t tof Time of flight of particle at this hit
+    // Return:
+    //   none.
     AliITSgeom *gm = ((AliITS*)gAlice->GetDetector("ITS"))->GetITSgeom();
     Float_t g[3],l[3];
 
@@ -376,86 +462,31 @@ void AliITShit::GetPositionL0(Double_t &x,Double_t &y,Double_t &z,
     g[1] = fy0;
     g[2] = fz0;
     if(gm) {
-      gm->GtoL(fLayer,fLadder,fDet,g,l);
-      x = l[0];
-      y = l[1];
-      z = l[2];
+        gm->GtoL(fModule,g,l);
+        x = l[0];
+        y = l[1];
+        z = l[2];
     } else {
-      Error("AliITShit","NULL pointer to the geometry! return smth else",gm);
-      // AliITSv7 - SDD case
-      x=fx0;
-      y=fy0;
-      z=fz0;
+        Error("AliITShit","NULL pointer to the geometry! return smth else",gm);
+        x=fx0;
+        y=fy0;
+        z=fz0;
     }
     tof = ft0;
     return;
 }
 //______________________________________________________________________
-Float_t AliITShit::GetXL(){
-////////////////////////////////////////////////////////////////////////
-//     Returns the x position of this hit in the local coordinates of this
-// module, and in the units of the Monte Carlo.
-////////////////////////////////////////////////////////////////////////
-    AliITSgeom *gm = ((AliITS*)gAlice->GetDetector("ITS"))->GetITSgeom();
-    Float_t g[3],l[3];
-
-    g[0] = fX;
-    g[1] = fY;
-    g[2] = fZ;
-    if(gm) {
-      gm->GtoL(fLayer,fLadder,fDet,g,l);
-      return l[0];
-    } else {
-      Error("AliITShit","NULL pointer to the geometry! return smth else",gm);
-      return fX;
-    }
-}
-//______________________________________________________________________
-Float_t AliITShit::GetYL(){
-////////////////////////////////////////////////////////////////////////
-//     Returns the y position of this hit in the local coordinates of this
-// module, and in the units of the Monte Carlo.
-////////////////////////////////////////////////////////////////////////
-    AliITSgeom *gm = ((AliITS*)gAlice->GetDetector("ITS"))->GetITSgeom();
-    Float_t g[3],l[3];
-
-    g[0] = fX;
-    g[1] = fY;
-    g[2] = fZ;
-    if (gm) {
-      gm->GtoL(fLayer,fLadder,fDet,g,l);
-      return l[1];
-    } else {
-      Error("AliITShit","NULL pointer to the geometry! return smth else",gm);
-      return fZ;
-    }
-}
-//______________________________________________________________________
-Float_t AliITShit::GetZL(){
-////////////////////////////////////////////////////////////////////////
-//     Returns the z position of this hit in the local coordinates of this
-// module, and in the units of the Monte Carlo.
-////////////////////////////////////////////////////////////////////////
-    AliITSgeom *gm = ((AliITS*)gAlice->GetDetector("ITS"))->GetITSgeom();
-    Float_t g[3],l[3];
-
-    g[0] = fX;
-    g[1] = fY;
-    g[2] = fZ;
-    if(gm) {
-      gm->GtoL(fLayer,fLadder,fDet,g,l);
-      return l[2];
-    } else {
-      Error("AliITShit","NULL pointer to the geometry! return smth else",gm);
-      return fY;
-    }
-}
-//______________________________________________________________________
 void AliITShit::GetMomentumL(Float_t &px,Float_t &py,Float_t &pz){
-////////////////////////////////////////////////////////////////////////
-//     Returns the momentum of this hit in the local coordinates of this
-// module, and in the units of the Monte Carlo.
-////////////////////////////////////////////////////////////////////////
+    //     Returns the momentum of this hit in the local coordinates of this
+    // module, and in the units of the Monte Carlo.
+    // Inputs:
+    //   none.
+    // Outputs:
+    //   Float_t px   Track x momentum at this hit [GeV/c]
+    //   Float_t py   Track y momentum at this hit [GeV/c]
+    //   Float_t pz   Track z momentum at this hit [GeV/c]
+    // Return:
+    //   none.
     AliITSgeom *gm = ((AliITS*)gAlice->GetDetector("ITS"))->GetITSgeom();
     Float_t g[3],l[3];
 
@@ -463,107 +494,60 @@ void AliITShit::GetMomentumL(Float_t &px,Float_t &py,Float_t &pz){
     g[1] = fPy;
     g[2] = fPz;
     if (gm) {
-      gm->GtoLMomentum(fLayer,fLadder,fDet,g,l);
-      px = l[0];
-      py = l[1];
-      pz = l[2];
+        gm->GtoLMomentum(fModule,g,l);
+        px = l[0];
+        py = l[1];
+        pz = l[2];
     } else {
-      Error("AliITShit","NULL pointer to the geometry! return smth else",gm);
-      px=fPx;
-      py=fPy;
-      pz=fPz;
-    }
+        Error("AliITShit","NULL pointer to the geometry! return smth else",gm);
+        px=fPx;
+        py=fPy;
+        pz=fPz;
+    } // end if
     return;
 }
 //______________________________________________________________________
-Float_t AliITShit::GetPXL(){
-////////////////////////////////////////////////////////////////////////
-//     Returns the X momentum of this hit in the local coordinates of this
-// module, and in the units of the Monte Carlo.
-////////////////////////////////////////////////////////////////////////
-    AliITSgeom *gm = ((AliITS*)gAlice->GetDetector("ITS"))->GetITSgeom();
-    Float_t g[3],l[3];
-
-    g[0] = fPx;
-    g[1] = fPy;
-    g[2] = fPz;
-    if (gm) {
-      gm->GtoLMomentum(fLayer,fLadder,fDet,g,l);
-      return l[0];
-    } else {
-      Error("AliITShit","NULL pointer to the geometry! return smth else",gm);
-      return fPx;
-    }
-}
-//______________________________________________________________________
-Float_t AliITShit::GetPYL(){
-////////////////////////////////////////////////////////////////////////
-//     Returns the Y momentum of this hit in the local coordinates of this
-// module, and in the units of the Monte Carlo.
-////////////////////////////////////////////////////////////////////////
-    AliITSgeom *gm = ((AliITS*)gAlice->GetDetector("ITS"))->GetITSgeom();
-    Float_t g[3],l[3];
-
-    g[0] = fPx;
-    g[1] = fPy;
-    g[2] = fPz;
-    if (gm) {
-      gm->GtoLMomentum(fLayer,fLadder,fDet,g,l);
-      return l[1];
-    } else {
-      Error("AliITShit","NULL pointer to the geometry! return smth else",gm);
-      return fPy;
-    }
-
-}
-//______________________________________________________________________
-Float_t AliITShit::GetPZL(){
-////////////////////////////////////////////////////////////////////////
-//     Returns the Z momentum of this hit in the local coordinates of this
-// module, and in the units of the Monte Carlo.
-////////////////////////////////////////////////////////////////////////
-    AliITSgeom *gm = ((AliITS*)gAlice->GetDetector("ITS"))->GetITSgeom();
-    Float_t g[3],l[3];
-
-    g[0] = fPx;
-    g[1] = fPy;
-    g[2] = fPz;
-    if (gm) {
-      gm->GtoLMomentum(fLayer,fLadder,fDet,g,l);
-      return l[2];
-    } else {
-      Error("AliITShit","NULL pointer to the geometry! return smth else",gm);
-      return fPz;
-    }
+TParticle * AliITShit::GetParticle() const {
+    //     Returns the pointer to the TParticle for the particle that created
+    // this hit. From the TParticle all kinds of information about this 
+    // particle can be found. See the TParticle class.
+    // Inputs:
+    //   none.
+    // Outputs:
+    //   none.
+    // Return:
+    //   The TParticle of the track that created this hit.
 
+    return gAlice->GetMCApp()->Particle(GetTrack());
 }
-//___________________________________________________________________________;
-Int_t AliITShit::GetModule(){
-////////////////////////////////////////////////////////////////////////
-//     Returns the module index number of the module where this hit was in.
-////////////////////////////////////////////////////////////////////////
+//----------------------------------------------------------------------
+void AliITShit::GetDetectorID(Int_t &layer,Int_t &ladder,Int_t &det)const{
+    // Returns the layer ladder and detector number lables for this
+    // ITS module. The use of layer, ladder and detector number for
+    // discribing the ITS is obsoleate.
+    // Inputs:
+    //   none.
+    // Outputs:
+    //   Int_t   &layer   Layer lable
+    //   Int_t   &ladder  Ladder lable
+    //   Int_t   &det     Detector lable
+    // Return:
+    //    none.
     AliITSgeom *gm = ((AliITS*)gAlice->GetDetector("ITS"))->GetITSgeom();
 
-    if (gm) return gm->GetModuleIndex(fLayer,fLadder,fDet);
-    else {
-      Error("AliITShit","NULL pointer to the geometry! return smth else",gm);
-      return 0;
-    }
-}
-//______________________________________________________________________
-TParticle * AliITShit::GetParticle() const {
-////////////////////////////////////////////////////////////////////////
-//     Returns the pointer to the TParticle for the particle that created
-// this hit. From the TParticle all kinds of information about this 
-// particle can be found. See the TParticle class.
-////////////////////////////////////////////////////////////////////////
-    return gAlice->GetMCApp()->Particle(GetTrack());
+    gm->GetModuleId(fModule,layer,ladder,det);
+    return;
 }  
 //----------------------------------------------------------------------
 void AliITShit::Print(ostream *os) const {
-////////////////////////////////////////////////////////////////////////
-// Standard output format for this class.
-////////////////////////////////////////////////////////////////////////
+    // Standard output format for this class.
+    // Inputs:
+    //   ostream *os   The output stream
+    // Outputs:
+    //   none.
+    // Return:
+    //   none.
+
 #if defined __GNUC__
 #if __GNUC__ > 2
     ios::fmtflags fmt;
@@ -583,7 +567,7 @@ void AliITShit::Print(ostream *os) const {
     fmt = os->setf(ios::hex); // set hex for fStatus only.
     *os << fStatus << " ";
     fmt = os->setf(ios::dec); // every thing else decimel.
-    *os << fLayer << " " << fLadder << " " << fDet << " ";;
+    *os << fModule << " ";
     *os << fPx << " " << fPy << " " << fPz << " ";
     *os << fDestep << " " << fTof;
     *os << " " << fx0 << " " << fy0 << " " << fz0;
@@ -593,32 +577,44 @@ void AliITShit::Print(ostream *os) const {
 }
 //----------------------------------------------------------------------
 void AliITShit::Read(istream *is) {
-////////////////////////////////////////////////////////////////////////
-// Standard input format for this class.
-////////////////////////////////////////////////////////////////////////
+    // Standard input format for this class.
+    // Inputs:
+    //   istream *is  the input stream
+    // Outputs:
+    //   none.
+    // Return:
+    //   none.
 
     *is >> fTrack >> fX >> fY >> fZ;
-    *is >> fStatus >> fLayer >> fLadder >> fDet >> fPx >> fPy >> fPz >>
-          fDestep >> fTof;
+    *is >> fStatus >> fModule >> fPx >> fPy >> fPz >> fDestep >> fTof;
     *is >> fx0 >> fy0 >> fz0;
     return;
 }
 //----------------------------------------------------------------------
 ostream &operator<<(ostream &os,AliITShit &p){
-////////////////////////////////////////////////////////////////////////
-// Standard output streaming function.
-////////////////////////////////////////////////////////////////////////
+    // Standard output streaming function.
+    // Inputs:
+    //   ostream os  The output stream
+    //   AliITShit p The his to be printed out
+    // Outputs:
+    //   none.
+    // Return:
+    //   The input stream
+
     p.Print(&os);
     return os;
 }
 //----------------------------------------------------------------------
 istream &operator>>(istream &is,AliITShit &r){
-////////////////////////////////////////////////////////////////////////
-// Standard input streaming function.
-////////////////////////////////////////////////////////////////////////
+    // Standard input streaming function.
+    // Inputs:
+    //   istream is  The input stream
+    //   AliITShit p The AliITShit class to be filled from this input stream
+    // Outputs:
+    //   none.
+    // Return:
+    //   The input stream
+
     r.Read(&is);
     return is;
 }
index a750127d8a2a7cdc9d70e7c479a18c6b403099f7..020c65e0922034d162719695200f918c16ddc763 100644 (file)
 //
 //
 ////////////////////////////////////////////////////////////////////////
+#include <TLorentzVector.h>
 
 #include "AliHit.h" 
 
-class TLorentzVector;
 class TParticle;
 
 class AliITShit : public AliHit {
@@ -98,127 +98,148 @@ class AliITShit : public AliHit {
     AliITShit(Int_t shunt, Int_t track, Int_t *vol, Float_t *hits);
     // New Standard Constructor
     AliITShit(Int_t shunt,Int_t track,Int_t *vol,Float_t edep,Float_t tof,
-             TLorentzVector &x,TLorentzVector &x0,TLorentzVector &p);
+              TLorentzVector &x,TLorentzVector &x0,TLorentzVector &p);
+    // Copy Constructor
+    AliITShit(const AliITShit &h);
+    // Equals operator
+    AliITShit& operator=(const AliITShit &h);
     // Default destructor
-    virtual ~AliITShit() {}
+    virtual ~AliITShit() {};
     // Get Hit information functions.
     // virtual int GetTrack() const {return fTrack;} // define in AliHit
     // virtual void SetTrack(int track) const {fTrack=track;) // AliHit
+    virtual void SetModule(Int_t mod){fModule=mod;};
+    virtual void SetShunt(Int_t shunt);
+    virtual void SetPosition(TLorentzVector &x){fX=x.X();fY=x.Y();fZ=x.Z();}
+    virtual void SetStartPosition(TLorentzVector &x){fx0=x.X();fy0=x.Y();
+                                                     fz0=x.Z();}
+    virtual void SetTime(Float_t t){fTof = t;}
+    virtual void SetStartTime(Float_t t){ft0 = t;}
+    virtual void SetStatus(Int_t stat){fStatus = stat;}
+    virtual void SetStartStatus(Int_t stat){fStatus0 = stat;}
+    virtual void SetEdep(Float_t de){fDestep = de;}
+    virtual void SetMomentum(TLorentzVector &p){fPx=p.Pz();fPy=p.Py();
+                                                fPz=p.Pz();}
     virtual Int_t GetTrackStatus() const {//returns the status code
-       return fStatus;}
+        return fStatus;}
     virtual Int_t GetTrackStatus0() const {//returns the status code
-       return fStatus0;}
-    virtual Int_t GetLayer() const {// returns the layer number
-       return fLayer;}
-    virtual Int_t GetLadder() const {// returns the ladder number
-       return fLadder;}
-    virtual Int_t GetDetector() const {// returns the detector number
-       return fDet;}
-    virtual void  GetDetectorID(Int_t &layer,Int_t &ladder,Int_t &det)const {
+        return fStatus0;}
+    virtual Int_t GetLayer() const{Int_t a,b,c;// returns the layer number
+    GetDetectorID(a,b,c); return a;}
+    virtual Int_t GetLadder() const{Int_t a,b,c;// returns the ladder number
+    GetDetectorID(a,b,c); return b;}
+    virtual Int_t GetDetector() const{Int_t a,b,c;//returns the detector number
+    GetDetectorID(a,b,c); return c;}
        // returns the detector ID
-       layer=fLayer;ladder=fLadder;det=fDet;return;};
-    virtual Int_t GetModule();
-    virtual Float_t GetIonization() const {// returns the Destep
-       return fDestep;}
+    virtual void  GetDetectorID(Int_t &layer,Int_t &ladder,Int_t &det)const;
+    virtual Int_t GetModule(){return fModule;};
+    virtual Float_t GetIonization() const {return fDestep;}//returns the Destep
     //
     virtual void GetPositionG(Float_t &x,Float_t &y,Float_t &z)const {
-       // returns the position in the Global frame
-       x=fX;y=fY;z=fZ;return;};
+        // returns the position in the Global frame
+        x=fX;y=fY;z=fZ;return;};
     virtual void GetPositionG(Double_t &x,Double_t &y,Double_t &z)const {
-       // returns the position in the Global frame
-       x=fX;y=fY;z=fZ;return;};
+        // returns the position in the Global frame
+        x=fX;y=fY;z=fZ;return;};
     virtual Float_t GetTOF() const {// returns the time of flight
-       return fTof;}
+        return fTof;}
     // Returns particle 3 position at this hit in global coordinates.
     virtual void GetPositionG(Float_t &x,Float_t &y,Float_t &z,Float_t &tof)
-       const {// returns the position in the Global frame and the time of
-       // flight
-       x=fX;y=fY;z=fZ,tof=fTof;return;};
+        const {// returns the position in the Global frame and the time of
+        // flight
+        x=fX;y=fY;z=fZ,tof=fTof;return;};
     virtual void GetPositionG(Double_t &x,Double_t &y,Double_t &z,Double_t &t)
-       const {// Returns particle 3 position and the time of flight at this
-       // hit in global coordinates.
-       x=fX;y=fY;z=fZ,t=fTof;return;};
+        const {// Returns particle 3 position and the time of flight at this
+        // hit in global coordinates.
+        x=fX;y=fY;z=fZ,t=fTof;return;};
     virtual Float_t GetXG()const {// Returns particle X position at this hit
-       // in global coordinates.
-       return fX;}
+        // in global coordinates.
+        return fX;}
     virtual Float_t GetYG()const {// Returns particle X position at this hit
-       // in global coordinates.
-       return fY;}
+        // in global coordinates.
+        return fY;}
     virtual Float_t GetZG()const {// Returns particle Z position at this hit
-       // in global coordinates.
-       return fZ;}
+        // in global coordinates.
+        return fZ;}
     // Returns particle 3 position at this hit in global coordinates.
     virtual void GetPositionG0(Float_t &x,Float_t &y,Float_t &z,Float_t &tof)
-       const {// returns the initial position in the Global frame and the
-       // time of flight
-       x=fx0;y=fy0;z=fz0,tof=fTof;return;};
+        const {// returns the initial position in the Global frame and the
+        // time of flight
+        x=fx0;y=fy0;z=fz0,tof=fTof;return;};
     // Returns particle 3 position at this hit in global coordinates.
     virtual void GetPositionG0(Double_t &x,Double_t &y,Double_t &z,
-                              Double_t &tof)
-       const {// returns the initial position in the Global frame and the
-       // time of flight
-       x=fx0;y=fy0;z=fz0,tof=fTof;return;};
-    virtual void GetPositionL(Float_t &x,Float_t &y,Float_t &z);
-    // Returns particle 3 position at this hit in local coordinates.
+                               Double_t &tof)const {
+        // returns the initial position in the Global frame and the
+        // time of flight
+        x=fx0;y=fy0;z=fz0,tof=fTof;return;};
+    virtual void GetPositionL(Float_t &x,Float_t &y,Float_t &z){
+        // Returns particle 3 position at this hit in local coordinates.
+        Float_t tf;GetPositionL(x,y,z,tf);}
     virtual void GetPositionL(Float_t &x,Float_t &y,Float_t &z,Float_t &tof);
     virtual void GetPositionL(Double_t &x,Double_t &y,Double_t &z){
-        // Returns particle 3 position at this hit in local coordinates.
-        Float_t xf,yf,zf;GetPositionL(xf,yf,zf);x=xf,y=yf;z=zf;}
+        // Returns particle 3 position at this hit in local coordinates.
+        Float_t xf,yf,zf,tf;GetPositionL(xf,yf,zf,tf);x=xf,y=yf;z=zf;}
     virtual void GetPositionL(Double_t &x,Double_t &y,Double_t &z,Double_t &t){
-    // Returns particle 3 position and the time of flight at this hit
-    // in local coordinates.
-        Float_t xf,yf,zf,tf;GetPositionL(xf,yf,zf,tf);x=xf,y=yf;z=zf;t=tf;}
+        // Returns particle 3 position and the time of flight at this hit
+        // in local coordinates.
+        Float_t xf,yf,zf,tf;GetPositionL(xf,yf,zf,tf);x=xf,y=yf;z=zf;t=tf;}
     // Returns particle 3 initial position and the time of flight at this hit
     // in local coordinates.
-    virtual void GetPositionL0(Double_t &x,Double_t &y,Double_t &z,Double_t &t);
-    virtual Float_t GetXL();
-    // Returns particle X position at this hit in local coordinates.
-    virtual Float_t GetYL();
-    // Returns particle Y position at this hit in local coordinates.
-    virtual Float_t GetZL();
-    // Returns particle Z position at this hit in local coordinates.
+    virtual void GetPositionL0(Double_t &x,Double_t &y,Double_t &z,
+                               Double_t &t);
+    virtual Float_t GetXL(){
+        // Returns particle X position at this hit in local coordinates.
+        Float_t xf,yf,zf,tf;GetPositionL(xf,yf,zf,tf);return xf;}
+    virtual Float_t GetYL(){
+        // Returns particle Y position at this hit in local coordinates.
+        Float_t xf,yf,zf,tf;GetPositionL(xf,yf,zf,tf);return yf;}
+    virtual Float_t GetZL(){
+        // Returns particle Z position at this hit in local coordinates.
+        Float_t xf,yf,zf,tf;GetPositionL(xf,yf,zf,tf);return zf;}
     // Get Monti Carlo information about hit.
     virtual void GetMomentumG(Float_t &px,Float_t &py,Float_t &pz)const {
-       // returns the particle momentum in the Global frame
-       px=fPx;py=fPy;pz=fPz;return;};
+        // returns the particle momentum in the Global frame
+        px=fPx;py=fPy;pz=fPz;return;};
     virtual void GetMomentumG(Double_t &px,Double_t &py,Double_t &pz)const {
-       // returns the particle momentum in the Global frame
-       px=fPx;py=fPy;pz=fPz;return;};
+        // returns the particle momentum in the Global frame
+        px=fPx;py=fPy;pz=fPz;return;};
     virtual Float_t GetPXG()const {// Returns particle X momentum at this hit
-       // in global coordinates.
-       return fPx;}
+        // in global coordinates.
+        return fPx;}
     virtual Float_t GetPYG()const {// Returns particle Y momentum at
-       // this hit in global coordinates.
-       return fPy;}
+        // this hit in global coordinates.
+        return fPy;}
     virtual Float_t GetPZG()const {// Returns particle Z momentum at
-       // this hit in global coordinates.
-       return fPz;}
+        // this hit in global coordinates.
+        return fPz;}
     virtual void GetMomentumL(Float_t &px,Float_t &py,Float_t &pz);
     virtual void GetMomentumL(Double_t &px,Double_t &py,Double_t &pz){
-       // Returns particle 3 momentum at this hit in local coordinates.         
-           Float_t x,y,z;GetMomentumL(x,y,z);px=x,py=y,pz=z;}
-    
-    virtual Float_t GetPXL();
+        // Returns particle 3 momentum at this hit in local coordinates.        
+        Float_t x,y,z;GetMomentumL(x,y,z);px=x,py=y,pz=z;}
+    virtual Float_t GetPXL(){Float_t px,py,pz;GetMomentumL(px,py,pz);
+                             return px;}
     // Returns particle X momentum at this hit in local coordinates.
-    virtual Float_t GetPYL();
+    virtual Float_t GetPYL(){Float_t px,py,pz;GetMomentumL(px,py,pz);
+                             return py;}
     // Returns particle Y momentum at this hit in local coordinates.
-    virtual Float_t GetPZL();
+    virtual Float_t GetPZL(){Float_t px,py,pz;GetMomentumL(px,py,pz);
+                             return pz;}
     // Returns particle Z momentum at this hit in local coordinates.
     virtual TParticle * GetParticle() const; // Returns ptr to this particle.
     Bool_t StatusInside() const {// checks if the particle is "inside"
-       if((fStatus&0x0001)==0) return kFALSE;else return kTRUE;}
+        if((fStatus&0x0001)==0) return kFALSE;else return kTRUE;}
     Bool_t StatusEntering() const {// checks if the particle is "entering"
-       if((fStatus&0x0002)==0) return kFALSE;else return kTRUE;}
+        if((fStatus&0x0002)==0) return kFALSE;else return kTRUE;}
     Bool_t StatusExiting() const {// checks if the particle is "exiting"
-       if((fStatus&0x0004)==0) return kFALSE;else return kTRUE;}
+        if((fStatus&0x0004)==0) return kFALSE;else return kTRUE;}
     Bool_t StatusOut() const {// checks if the particle is "out"
-       if((fStatus&0x0008)==0) return kFALSE;else return kTRUE;}
+        if((fStatus&0x0008)==0) return kFALSE;else return kTRUE;}
     Bool_t StatusDisappeared() const {// checks if the part. is "disappeared"
-       if((fStatus&0x00010)==0) return kFALSE;else return kTRUE;}
+        if((fStatus&0x00010)==0) return kFALSE;else return kTRUE;}
     Bool_t StatusStop() const {// checks if the particle is "stopped"
-       if((fStatus&0x00020)==0) return kFALSE;else return kTRUE;}
+        if((fStatus&0x00020)==0) return kFALSE;else return kTRUE;}
     Bool_t StatusAlive() const {// checks if the particle is "alive"
-       if((fStatus&0x00030)==0) return kFALSE;else return kTRUE;}
+        if((fStatus&0x00030)==0) return kFALSE;else return kTRUE;}
     // Prints out the content of this class in ASCII format.
     void Print(ostream *os) const; 
     // Reads in the content of this class in the format of Print
@@ -229,9 +250,7 @@ class AliITShit : public AliHit {
 
  protected:
     Int_t     fStatus; // Track Status
-    Int_t     fLayer;  // Layer number
-    Int_t     fLadder; // Ladder number
-    Int_t     fDet;    // Detector number  
+    Int_t     fModule; // Module number 
     Float_t   fPx;     // PX of particle at the point of the hit
     Float_t   fPy;     // PY of particle at the point of the hit
     Float_t   fPz;     // PZ of particle at the point of the hit
@@ -243,7 +262,7 @@ class AliITShit : public AliHit {
     Float_t   fz0;     // Starting point of this step
     Float_t   ft0;     // Starting point of this step
 
-    ClassDef(AliITShit,2)  //Hits object for set:ITS
+    ClassDef(AliITShit,3)  //Hits object for set:ITS
         
 }; 
 // Input and output function for standard C++ input/output.
index 2a56a44ae052332e5240b67cddd3f3b1339bfad1..27f5dc983e6f6fe3dc404a9901e78a1ed3b0a593 100644 (file)
@@ -62,20 +62,26 @@ ClassImp(AliITSv11)
 
 
 //______________________________________________________________________
-AliITSv11::AliITSv11() : AliITS(),
-  fGeomDetOut(kFALSE),
-  fGeomDetIn(kFALSE),
-  fByThick(kTRUE),
-  fMajorVersion(11),
-  fMinorVersion(0),
-  fSDDgeom(0)
+AliITSv11::AliITSv11() : 
+AliITS(),
+fGeomDetOut(kFALSE),
+fGeomDetIn(kFALSE),
+fByThick(kTRUE),
+fMajorVersion(IsVersion()),
+fMinorVersion(0),
+fEuclidGeomDet(),
+fRead(),
+fWrite(),
+//fSPDgeom(),
+fSDDgeom(0),
+//fSupgeom(),
+fIgm(kv11)
 {
   //    Standard default constructor for the ITS version 11.
 
     fIdN          = 0;
     fIdName       = 0;
     fIdSens       = 0;
-    fEuclidOut    = kFALSE; // Don't write Euclide file
     Int_t i;
     for(i=0;i<60;i++) fRead[i] = '\0';
     for(i=0;i<60;i++) fWrite[i] = '\0';
@@ -85,14 +91,20 @@ AliITSv11::AliITSv11() : AliITS(),
 
 
 //______________________________________________________________________
-AliITSv11::AliITSv11(const char *name, const char *title)
-  : AliITS("ITS", title),
-    fGeomDetOut(kFALSE),
-    fGeomDetIn(kFALSE),
-    fByThick(kTRUE),
-    fMajorVersion(11),
-    fMinorVersion(0),
-    fSDDgeom(0)
+AliITSv11::AliITSv11(const char *name, const char *title): 
+AliITS("ITS", title),
+fGeomDetOut(kFALSE),
+fGeomDetIn(kFALSE),
+fByThick(kTRUE),
+fMajorVersion(IsVersion()),
+fMinorVersion(0),
+fEuclidGeomDet(),
+fRead(),
+fWrite(),
+//fSPDgeom(),
+fSDDgeom(0),
+//fSupgeom(),
+fIgm(kv11)
 {
   //    Standard constructor for the ITS version 11.
 
@@ -110,8 +122,6 @@ AliITSv11::AliITSv11(const char *name, const char *title)
   fIdName[5] = "ITS6";
   fIdSens    = new Int_t[fIdN];
   for(i=0;i<fIdN;i++) fIdSens[i] = 0;
-  fEuclidOut    = kFALSE; // Don't write Euclide file
-  //SetDensityServicesByThickness();
   // not needed, fByThick set to kTRUE in in the member initialization lis
   
 
@@ -121,19 +131,23 @@ AliITSv11::AliITSv11(const char *name, const char *title)
   strncpy(fWrite,fEuclidGeomDet,60);
   strncpy(fRead,"$ALICE_ROOT/ITS/ITSgeometry_vPPRasymmFMD.det",60);
 }
-
-
 //______________________________________________________________________
 AliITSv11::AliITSv11(Int_t debugITS,Int_t debugSPD,Int_t debugSDD,
                   Int_t debugSSD,Int_t debugSUP) :
-  AliITS("ITS","ITS geometry v11"),
-    fGeomDetOut(kFALSE),
-    fGeomDetIn(kFALSE),
-    fByThick(kTRUE),
-    fMajorVersion(11),
-    fMinorVersion(0),
-    fSDDgeom(0)
- {
+AliITS("ITS","ITS geometry v11"),
+fGeomDetOut(kFALSE),
+fGeomDetIn(kFALSE),
+fByThick(kTRUE),
+fMajorVersion(IsVersion()),
+fMinorVersion(0),
+fEuclidGeomDet(),
+fRead(),
+fWrite(),
+//fSPDgeom(),
+fSDDgeom(0),
+//fSuppgeom(),
+fIgm(kv11)
+{
   // Standard default constructor for the ITS version 11.
 
 
@@ -154,7 +168,6 @@ AliITSv11::AliITSv11(Int_t debugITS,Int_t debugSPD,Int_t debugSDD,
   fIdSens    = new Int_t[fIdN];
   for(i=0;i<fIdN;i++) fIdSens[i] = 0;
   fEuclidOut    = kFALSE; // Don't write Euclide file
-  //SetDensityServicesByThickness();
   
   fEuclidGeometry="$ALICE_ROOT/ITS/ITSgeometry_vPPRasymm2.euc";
   strncpy(fEuclidGeomDet,"$ALICE_ROOT/ITS/ITSgeometry_vPPRasymm2.det",60);
@@ -164,40 +177,44 @@ AliITSv11::AliITSv11(Int_t debugITS,Int_t debugSPD,Int_t debugSDD,
 
   debugITS = (debugSPD && debugSSD && debugSUP && debugSDD); //remove temp. warnings
 }
-
-
 //______________________________________________________________________
 AliITSv11::~AliITSv11() {
   delete fSDDgeom;
 }
-
-
 //______________________________________________________________________
 void AliITSv11::BuildGeometry(){
 
 }
-
-
 //______________________________________________________________________
 void AliITSv11::CreateGeometry(){
-  //
-  // Create ROOT geometry
-  //
-
-  TGeoManager *geoManager = gGeoManager;
-  TGeoVolume *vALIC = geoManager->GetTopVolume();
-
-  TGeoPcon *sITS = new TGeoPcon("ITS Top Volume",0.0,360.0,2);
-
-  // DefineSection(section number, Z, Rmin, Rmax).
-  const Double_t kcm = 1.0;
-  sITS->DefineSection(0,-300.0*kcm,0.01*kcm,50.0*kcm);
-  sITS->DefineSection(1,+300.0*kcm,0.01*kcm,50.0*kcm);
-
-  TGeoMedium *air = gGeoManager->GetMedium("ITS_AIR$");
-  TGeoVolume *vITS = new TGeoVolume("ITSV",sITS,air);
-  vITS->SetVisibility(kFALSE);
-  vALIC->AddNode(vITS,1,0);
+    //
+    // Create ROOT geometry
+    //
+    // These constant character strings are set by cvs during commit
+    // do not change them unless you know what you are doing!
+    const Char_t *cvsDate="$Date$";
+    const Char_t *cvsRevision="$Revision$";
+
+    TGeoManager *geoManager = gGeoManager;
+    TGeoVolume *vALIC = geoManager->GetTopVolume();
+
+    TGeoPcon *sITS = new TGeoPcon("ITS Top Volume",0.0,360.0,2);
+
+    // DefineSection(section number, Z, Rmin, Rmax).
+    const Double_t kcm = 1.0;
+    sITS->DefineSection(0,-300.0*kcm,0.01*kcm,50.0*kcm);
+    sITS->DefineSection(1,+300.0*kcm,0.01*kcm,50.0*kcm);
+
+    TGeoMedium *air = gGeoManager->GetMedium("ITS_AIR$");
+    TGeoVolume *vITS = new TGeoVolume("ITSV",sITS,air);
+    vITS->SetVisibility(kFALSE);
+    const Int_t length=100;
+    Char_t vstrng[length];
+    if(fIgm.WriteVersionString(vstrng,length,(AliITSVersion_t)IsVersion(),
+                               fMinorVersion,cvsDate,cvsRevision))
+        vITS->SetTitle(vstrng);
+    //printf("Title set to %s\n",vstrng);
+    vALIC->AddNode(vITS,1,0);
 
 //   fSPDgeom->CenteralSPD(vITS);
 
@@ -1198,7 +1215,7 @@ void AliITSv11::CreateMaterials(){
     AliMaterial(96, "SSD cone$",63.546, 29., 1.15, 1.265, 999);
     AliMedium(96,"SSD cone$",96,0,ifield,fieldm,tmaxfdServ,stemaxServ,deemaxServ,epsilServ,stminServ);
 }
-
+/*
 //______________________________________________________________________
 void AliITSv11::InitAliITSgeom(){
   //
@@ -1311,7 +1328,7 @@ void AliITSv11::InitAliITSgeom(){
 
 //   fSDDgeom->ExportSensorGeometry(GetITSgeom(), +3, 0);  //SDD
 }
-
+*/
 //______________________________________________________________________
 void AliITSv11::Init(){
   //
@@ -1320,6 +1337,12 @@ void AliITSv11::Init(){
 
   //AliInfo(Form("Minor version %d",fMinorVersion));
     //
+    UpdateInternalGeometry();
+    AliITS::Init();
+    if(fGeomDetOut) GetITSgeom()->WriteNewFile(fWrite);
+
+    //
+/*
     if(fRead[0]=='\0') strncpy(fRead,fEuclidGeomDet,60);
     if(fWrite[0]=='\0') strncpy(fWrite,fEuclidGeomDet,60);
     if(GetITSgeom()!=0) SetITSgeom(0x0);
@@ -1329,7 +1352,7 @@ void AliITSv11::Init(){
     else this->InitAliITSgeom();
     if(fGeomDetOut) GetITSgeom()->WriteNewFile(fWrite);
     AliITS::Init();
-    //
+*/    //
 }
 
 // //______________________________________________________________________
index 2d28e535042852b7197e61358e1d498b927166d2..1a572628112cbcff40660b89edacdfb08ea03e80 100644 (file)
@@ -10,7 +10,7 @@
 //
 // B. Nilsen, L. Gaudichet
 //************************************************************************
+#include "AliITSInitGeometry.h"
 #include "AliITS.h"
 class AliITSv11GeometrySPD;
 class AliITSv11GeometrySDD;
@@ -34,7 +34,7 @@ class AliITSv11 : public AliITS {
     //virtual AliITSv11GeometrySPD*     GetSPDGeometry(){return fSPDgeom;}
     virtual AliITSv11GeometrySDD*    GetSDDGeometry(){return fSDDgeom;}
     //virtual AliITSv11GeometrySupport* GetSupGeometry(){return fSupgeom;}
-    virtual Int_t  IsVersion() const { return fMajorVersion;}  // ITS version number 
+    virtual Int_t  IsVersion() const { return kv11;}  // ITS version number 
     virtual Int_t  GetMajorVersion() const {// return Major Version Number
                     return fMajorVersion;}
     virtual Int_t  GetMinorVersion() const {// return Major Version Number
@@ -76,22 +76,21 @@ class AliITSv11 : public AliITS {
  private:
     AliITSv11(const AliITSv11 &source);            // copy constructor
     AliITSv11& operator=(const AliITSv11 &source); // assignment operator
-    void InitAliITSgeom();
+    //void InitAliITSgeom();
 
-    Bool_t   fGeomDetOut;       // Flag to write .det file out
-    Bool_t   fGeomDetIn;        // Flag to read .det file or directly from Geat.
-    Bool_t   fByThick;          // Flag to use services materials by thickness
+    Bool_t fGeomDetOut;       // Flag to write .det file out
+    Bool_t fGeomDetIn;        // Flag to read .det file or directly from Geat.
+    Bool_t fByThick;          // Flag to use services materials by thickness
                                 // ture, or mass false.
-    Int_t    fMajorVersion;     // Major version number == IsVersion
-    Int_t    fMinorVersion;     // Minor version number
-    char     fEuclidGeomDet[60];// file where detector transormation are define.
-    char     fRead[60];         //! file name to read .det file
-    char     fWrite[60];        //! file name to write .det file
-
-
+    Int_t  fMajorVersion;     // Major version number == IsVersion
+    Int_t  fMinorVersion;     // Minor version number
+    char   fEuclidGeomDet[60];// file where detector transormation are define.
+    char   fRead[60];         //! file name to read .det file
+    char   fWrite[60];        //! file name to write .det file
     //AliITSv11GeometrySPD *fSPDgeom;      //SPD Geometry
     AliITSv11GeometrySDD *fSDDgeom;      //! SDD Geometry
     //AliITSv11GeometrySupport /fSupgeom;  //Support Geometry
+    AliITSInitGeometry fIgm; //! Geometry initlization object
 
     ClassDef(AliITSv11,1)  // ITS version 11 
 };
index 034acc3e6fcdcad1bbdcf41d670f7acd8e3968b5..4fcb2d3568a24d9f649e323be91fe2dcc79594c3 100644 (file)
@@ -13,6 +13,9 @@
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
 
+// $Id$
+
+// $Log$
 
 //========================================================================
 //
@@ -20,6 +23,8 @@
 //
 //  This geometry is a mix between the old geometry (originally coded
 //  in AliITSvPPRasymmFMD) and the new TGeo geometry (v11).
+//  The flags which indicate whether the old or the new part is used
+//  is set in AliITSInitGeometry.cxx
 // 
 // Ludovic Gaudichet  (gaudichet@to.infn.it)
 //
@@ -82,9 +87,10 @@ AliITSv11Hybrid::AliITSv11Hybrid():
   fRails(0),
   fFluid(0),
   fIDMother(0),
+  fInitGeom((AliITSVersion_t)fMajorVersion,fMinorVersion),
   fSDDgeom(0)
  {
-    //    Standard default constructor for the ITS version 10.
+    //    Standard default constructor
     // Inputs:
     //   none.
     // Outputs:
@@ -112,8 +118,9 @@ AliITSv11Hybrid::AliITSv11Hybrid(const char *name, const char *title)
     fRails(0),
     fFluid(0),
     fIDMother(0),
+    fInitGeom((AliITSVersion_t)fMajorVersion,fMinorVersion),
     fSDDgeom(0) {
-    //    Standard constructor for the ITS version 10.
+    //    Standard constructor for the v11Hybrid geometry.
     // Inputs:
     //   const char * name   Ignored, set to "ITS"
     //   const char * title  Arbitrary title
@@ -642,6 +649,14 @@ void AliITSv11Hybrid::CreateGeometry() {
   CreateOldGeometry();
   TGeoVolume *vITS = geoManager->GetVolume("ITSV");
 
+  const Char_t *cvsDate="$Date$";
+  const Char_t *cvsRevision="$Revision$";
+  const Int_t length=100;
+  Char_t vstrng[length];
+  if(fInitGeom.WriteVersionString(vstrng,length,(AliITSVersion_t)IsVersion(),
+                            fMinorVersion,cvsDate,cvsRevision))
+    vITS->SetTitle(vstrng);
+
   if (AliITSInitGeometry::SDDIsTGeoNative()) {
     fSDDgeom->Layer3(vITS);
     fSDDgeom->Layer4(vITS);
@@ -5337,6 +5352,128 @@ void AliITSv11Hybrid::DrawModule() const{
     gMC->Gdman(17, 6, "MAN");
 }
 
+// //______________________________________________________________________
+// void AliITSv11Hybrid::StepManager(){
+//     //    Called for every step in the ITS, then calles the AliITShit class
+//     // creator with the information to be recoreded about that hit.
+//     //     The value of the macro ALIITSPRINTGEOM if set to 1 will allow the
+//     // printing of information to a file which can be used to create a .det
+//     // file read in by the routine CreateGeometry(). If set to 0 or any other
+//     // value except 1, the default behavior, then no such file is created nor
+//     // it the extra variables and the like used in the printing allocated.
+//     // Inputs:
+//     //   none.
+//     // Outputs:
+//     //   none.
+//     // Return:
+//     //   none.
+
+//     static TLorentzVector position0;
+//     static Int_t stat0=0;
+
+//     if(!(this->IsActive())) {
+//     return;
+//     } // end if !Active volume.
+
+//     if(!(gMC->TrackCharge())) return;
+
+//     Int_t kk = 0, copy;
+//     Int_t id = gMC->CurrentVolID(copy);
+//     while ((id != fIdSens[kk]) && (kk<6)) ++kk;
+
+//     if((kk<6) && (gMC->IsTrackExiting())) {
+//     copy = fTrackReferences->GetEntriesFast();
+//     TClonesArray &lTR = *fTrackReferences;
+//     // Fill TrackReference structure with this new TrackReference.
+//     new(lTR[copy]) AliTrackReference(gAlice->GetMCApp()->GetCurrentTrackNumber());
+//     } // if Outer ITS mother Volume
+
+//     Int_t   copy1, copy2;  
+//     Int_t   vol[5];
+//     TClonesArray &lhits = *fHits;
+
+//     // Track status
+//     vol[3] = 0;
+//     vol[4] = 0;
+//     if(gMC->IsTrackInside())      vol[3] +=  1;
+//     if(gMC->IsTrackEntering())    vol[3] +=  2;
+//     if(gMC->IsTrackExiting())     vol[3] +=  4;
+//     if(gMC->IsTrackOut())         vol[3] +=  8;
+//     if(gMC->IsTrackDisappeared()) vol[3] += 16;
+//     if(gMC->IsTrackStop())        vol[3] += 32;
+//     if(gMC->IsTrackAlive())       vol[3] += 64;
+
+//     // Fill hit structure.
+//     vol[0] = kk+1;
+//     Int_t sddModPos = 1, sddLaddPos = 2, sddIndShift = 0;
+//     if (AliITSInitGeometry::SDDIsTGeoNative()) {
+//       sddModPos     = 2;
+//       sddLaddPos    = 3;
+//       sddIndShift   = 1;
+//     };
+
+//     switch (kk) {
+
+//     case 0: { // SPD
+
+//       gMC->CurrentVolOffID(2,copy);  // det 1<->4
+//       vol[1] = copy;
+//       gMC->CurrentVolOffID(3,copy1); // lad 1<->2
+//       gMC->CurrentVolOffID(4,copy2); // mod 1<->10
+//       vol[2] = copy1+(copy2-1)*2; //# of ladders in one module  = 2
+//     } break;
+
+//     case 1: {
+
+//       gMC->CurrentVolOffID(2,copy);  // 1<->4
+//       vol[1] = copy;
+//       gMC->CurrentVolOffID(3,copy1); // 1<->4
+//       gMC->CurrentVolOffID(4,copy2); // 1<->10
+//       vol[2] = copy1+(copy2-1)*4; //# of ladders in one module  = 4
+//     } break;
+
+//     case 2: // SDD
+//     case 3: {
+
+//       gMC->CurrentVolOffID(sddModPos, copy); // 1<->6  and 1<->8
+//       vol[1] = copy + sddIndShift;
+//       gMC->CurrentVolOffID(sddLaddPos, copy);// 1<->14 and 1<->22
+//       vol[2] = copy + sddIndShift;
+//     } break;
+
+//     case 5: // SSD
+//     case 4: {
+
+//       gMC->CurrentVolOffID(1,copy); // 1<->22 and 1<->25
+//       vol[1] = copy;
+//       gMC->CurrentVolOffID(2,copy); // 1<->34 and 1<->38
+//       vol[2] = copy;
+//     } break;
+
+//     default: return; // not an ITS volume?
+//     }
+
+//     TLorentzVector position, momentum;
+//     gMC->TrackPosition(position);
+//     gMC->TrackMomentum(momentum);
+//     vol[4] = stat0;
+//     if(gMC->IsTrackEntering()) {
+//     position0 = position;
+//     stat0 = vol[3];
+//     return;
+//     } // end if IsEntering
+//     // Fill hit structure with this new hit.
+    
+//     new(lhits[fNhits++]) AliITShit(fIshunt,gAlice->GetMCApp()->GetCurrentTrackNumber(),vol,
+//                                gMC->Edep(),gMC->TrackTime(),position,
+//                                position0,momentum);
+
+//     position0 = position;
+//     stat0 = vol[3];
+
+//     return;
+// }
+
 //______________________________________________________________________
 void AliITSv11Hybrid::StepManager(){
     //    Called for every step in the ITS, then calles the AliITShit class
@@ -5353,43 +5490,36 @@ void AliITSv11Hybrid::StepManager(){
     // Return:
     //   none.
 
-    static TLorentzVector position0;
-    static Int_t stat0=0;
-
-    if(!(this->IsActive())) {
-       return;
-    } // end if !Active volume.
+    static TLorentzVector position, momentum; // Saves on calls to constructors
+    static AliITShit hit;// Saves on calls to constructors
 
+    if(!(this->IsActive())) return;
     if(!(gMC->TrackCharge())) return;
 
-    Int_t kk = 0, copy;
+    Int_t lay = 0, copy;
     Int_t id = gMC->CurrentVolID(copy);
-    while ((id != fIdSens[kk]) && (kk<6)) ++kk;
+    while ((id != fIdSens[lay]) && (lay<6)) ++lay;
 
-    if((kk<6) && (gMC->IsTrackExiting())) {
+    if((lay<6) && (gMC->IsTrackExiting())) {
        copy = fTrackReferences->GetEntriesFast();
        TClonesArray &lTR = *fTrackReferences;
        // Fill TrackReference structure with this new TrackReference.
        new(lTR[copy]) AliTrackReference(gAlice->GetMCApp()->GetCurrentTrackNumber());
     } // if Outer ITS mother Volume
 
-    Int_t   copy1, copy2;  
-    Int_t   vol[5];
-    TClonesArray &lhits = *fHits;
+    TClonesArray &lhits = *(Hits());
 
     // Track status
-    vol[3] = 0;
-    vol[4] = 0;
-    if(gMC->IsTrackInside())      vol[3] +=  1;
-    if(gMC->IsTrackEntering())    vol[3] +=  2;
-    if(gMC->IsTrackExiting())     vol[3] +=  4;
-    if(gMC->IsTrackOut())         vol[3] +=  8;
-    if(gMC->IsTrackDisappeared()) vol[3] += 16;
-    if(gMC->IsTrackStop())        vol[3] += 32;
-    if(gMC->IsTrackAlive())       vol[3] += 64;
+    Int_t status;
+    if(gMC->IsTrackInside())      status +=  1;
+    if(gMC->IsTrackEntering())    status +=  2;
+    if(gMC->IsTrackExiting())     status +=  4;
+    if(gMC->IsTrackOut())         status +=  8;
+    if(gMC->IsTrackDisappeared()) status += 16;
+    if(gMC->IsTrackStop())        status += 32;
+    if(gMC->IsTrackAlive())       status += 64;
 
     // Fill hit structure.
-    vol[0] = kk+1;
     Int_t sddModPos = 1, sddLaddPos = 2, sddIndShift = 0;
     if (AliITSInitGeometry::SDDIsTGeoNative()) {
       sddModPos     = 2;
@@ -5397,64 +5527,91 @@ void AliITSv11Hybrid::StepManager(){
       sddIndShift   = 1;
     };
 
-    switch (kk) {
+    Int_t copy1, copy2, lad, det, mod;  
+    switch (lay) {
 
     case 0: { // SPD
 
       gMC->CurrentVolOffID(2,copy);  // det 1<->4
-      vol[1] = copy;
+      det = copy;
       gMC->CurrentVolOffID(3,copy1); // lad 1<->2
       gMC->CurrentVolOffID(4,copy2); // mod 1<->10
-      vol[2] = copy1+(copy2-1)*2; //# of ladders in one module  = 2
+      lad = copy1+(copy2-1)*2; //# of ladders in one module  = 2
+      mod = (lad-1)*4 + det - 1;
     } break;
 
     case 1: {
 
       gMC->CurrentVolOffID(2,copy);  // 1<->4
-      vol[1] = copy;
+      det = copy;
       gMC->CurrentVolOffID(3,copy1); // 1<->4
       gMC->CurrentVolOffID(4,copy2); // 1<->10
-      vol[2] = copy1+(copy2-1)*4; //# of ladders in one module  = 4
+      lad = copy1+(copy2-1)*4; //# of ladders in one module  = 4
+      mod = 80 + (lad-1)*4 + det - 1;
+    } break;
+
+    case 2: { // SDD
+      
+      gMC->CurrentVolOffID(sddModPos, copy); // 1<->6  and 1<->8
+      det = copy + sddIndShift;
+      gMC->CurrentVolOffID(sddLaddPos, copy);// 1<->14 and 1<->22
+      lad = copy + sddIndShift;
+      mod = 240 + (lad-1)*6 + det - 1;
     } break;
 
-    case 2: // SDD
     case 3: {
 
       gMC->CurrentVolOffID(sddModPos, copy); // 1<->6  and 1<->8
-      vol[1] = copy + sddIndShift;
+      det = copy + sddIndShift;
       gMC->CurrentVolOffID(sddLaddPos, copy);// 1<->14 and 1<->22
-      vol[2] = copy + sddIndShift;
+      lad = copy + sddIndShift;
+      mod = 324 + (lad-1)*8 + det - 1;
+    } break;
+
+    case 4: { // SSD
+
+      gMC->CurrentVolOffID(1,copy); // 1<->22 and 1<->25
+      det = copy;
+      gMC->CurrentVolOffID(2,copy); // 1<->34 and 1<->38
+      lad = copy;
+      mod = 500 + (lad-1)*22 + det - 1;
     } break;
 
-    case 5: // SSD
-    case 4: {
+    case 5: {
 
       gMC->CurrentVolOffID(1,copy); // 1<->22 and 1<->25
-      vol[1] = copy;
+      det = copy;
       gMC->CurrentVolOffID(2,copy); // 1<->34 and 1<->38
-      vol[2] = copy;
+      lad = copy;
+      mod = 1248 + (lad-1)*25 + det - 1;
     } break;
 
     default: return; // not an ITS volume?
     }
 
-    TLorentzVector position, momentum;
+    hit.SetModule(mod);
+    hit.SetTrack(gAlice->GetMCApp()->GetCurrentTrackNumber());
     gMC->TrackPosition(position);
     gMC->TrackMomentum(momentum);
-    vol[4] = stat0;
-    if(gMC->IsTrackEntering()) {
-       position0 = position;
-       stat0 = vol[3];
-       return;
+    hit.SetPosition(position);
+    hit.SetTime(gMC->TrackTime());
+    hit.SetMomentum(momentum);
+    hit.SetStatus(status);
+    hit.SetEdep(gMC->Edep());
+    hit.SetShunt(GetIshunt());
+    if(gMC->IsTrackEntering()){
+        hit.SetStartPosition(position);
+        hit.SetStartTime(gMC->TrackTime());
+        hit.SetStartStatus(status);
+        return; // don't save entering hit.
     } // end if IsEntering
     // Fill hit structure with this new hit.
-    
-    new(lhits[fNhits++]) AliITShit(fIshunt,gAlice->GetMCApp()->GetCurrentTrackNumber(),vol,
-                                  gMC->Edep(),gMC->TrackTime(),position,
-                                  position0,momentum);
-
-    position0 = position;
-    stat0 = vol[3];
+    //Info("StepManager","Calling Copy Constructor");
+    new(lhits[fNhits++]) AliITShit(hit); // Use Copy Construtor.
+    // Save old position... for next hit.
+    hit.SetStartPosition(position);
+    hit.SetStartTime(gMC->TrackTime());
+    hit.SetStartStatus(status);
 
     return;
 }
index bef9dc611a9b060ceddce8c8e90e7555440b7be0..574ffb0174e280fe0abd07068846cd6ce24dd36e 100644 (file)
@@ -3,6 +3,10 @@
 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
  * See cxx source for full Copyright notice                               */
 
+// $Id$
+
+// $Log$
+
 //========================================================================
 //
 //            Geometry of the Inner Tracking System
@@ -15,6 +19,7 @@
 //========================================================================
  
 #include "AliITS.h"
+#include "AliITSInitGeometry.h"
 
 class  AliITSv11GeometrySDD;
 
@@ -113,7 +118,6 @@ class AliITSv11Hybrid : public AliITS {
     AliITSv11Hybrid& operator=(const AliITSv11Hybrid &source); // assignment operator
     void InitAliITSgeom();
 
-    // TString fEuclidGeomtery,fEuclidMaterial defined in AliModule.
     Bool_t fGeomDetOut;       // Flag to write .det file out
     Bool_t fGeomDetIn;        // Flag to read .det file or directly from Geat.
     Bool_t fByThick;          // Flag to use services materials by thickness
@@ -131,9 +135,10 @@ class AliITSv11Hybrid : public AliITS {
     Int_t    fFluid;          // flag to switch between water (=1) and freon (=0)
     Int_t fIDMother;          //! ITS Mother Volume id.
 
-    AliITSv11GeometrySDD *fSDDgeom;    //! SDD Geometry
+    AliITSInitGeometry fInitGeom;   //! Get access to decoding and AliITSgeom init functins
+    AliITSv11GeometrySDD *fSDDgeom; //! SDD Geometry
 
-    ClassDef(AliITSv11Hybrid,1)                          
+    ClassDef(AliITSv11Hybrid,2)                          
 };
  
 #endif
index a5db650d04d214d87792b4ce0cd6c0dac744b88e..17f7958492bdc395196060c58e3dd92f0fb95269 100644 (file)
@@ -90,21 +90,24 @@ const Double_t AliITSvBeamTestITS04::fgkSSD1y = 80.6;
 ClassImp(AliITSvBeamTestITS04)
     
 //_____________________________________________________________
-  AliITSvBeamTestITS04::AliITSvBeamTestITS04() : AliITS(),
-fITSmotherVolume(0),
-fNspd(fgkNumberOfSPD),
-fNsdd(fgkNumberOfSDD),
-fNssd(fgkNumberOfSSD),
-fGeomDetOut(kFALSE),
-fGeomDetIn(kFALSE){
+  AliITSvBeamTestITS04::AliITSvBeamTestITS04() : 
+AliITS(),              // Base class
+fITSmotherVolume(0),   // Pointer to ITS mother volume.
+fNspd(fgkNumberOfSPD), //Number of SPD modules
+fNsdd(fgkNumberOfSDD), //Number of SDD modules
+fNssd(fgkNumberOfSSD), //Number of SSD modules
+fGeomDetOut(kFALSE),   // Flag to write .det file out
+fGeomDetIn(kFALSE),    // Flag to read geometry file (JC)
+fWrite(),              //! file name to write .det file 
+fRead(),               // file name to read .det file (JC)
+fMajorVersion(kvITS04),// Major Version
+fMinorVersion(1),      // Minor Version
+fIgm(kvITS04)          //! Init geometry object
+{
     //
     // Constructor
     //
-    
-  // SetNumberOfSPD(fgkNumberOfSPD);
-  //  SetNumberOfSDD(fgkNumberOfSDD);
-  //  SetNumberOfSSD(fgkNumberOfSSD);
-    
+
     fIdN = 3;         
     fIdName    = new TString[fIdN];
     fIdName[0] = fgSPDsensitiveVolName;
@@ -113,33 +116,27 @@ fGeomDetIn(kFALSE){
     fIdSens    = new Int_t[fIdN];
     for(Int_t i=0; i<fIdN; i++) fIdSens[i] = 0;
     
-    //for writing out geometry
-    //fGeomDetOut   = kFALSE; 
-
-    // for reading in geometry (JC)
-    //fGeomDetIn = kFALSE;
-
     for(Int_t a=0;a<60;a++) fWrite[a] = '\0';
 }
-
 //_____________________________________________________________
-AliITSvBeamTestITS04::AliITSvBeamTestITS04(const char* name,const char *title)
-  : AliITS(name,title),
-fITSmotherVolume(0),
-fNspd(fgkNumberOfSPD),
-fNsdd(fgkNumberOfSDD),
-fNssd(fgkNumberOfSSD),
-fGeomDetOut(kFALSE),
-fGeomDetIn(kFALSE)
+AliITSvBeamTestITS04::AliITSvBeamTestITS04(const char* name,const char *title):
+AliITS(name,title),   // Base class
+fITSmotherVolume(0),   // Pointer to ITS mother volume.
+fNspd(fgkNumberOfSPD), //Number of SPD modules
+fNsdd(fgkNumberOfSDD), //Number of SDD modules
+fNssd(fgkNumberOfSSD), //Number of SSD modules
+fGeomDetOut(kFALSE),   // Flag to write .det file out
+fGeomDetIn(kFALSE),    // Flag to read geometry file (JC)
+fWrite(),              //! file name to write .det file 
+fRead(),               // file name to read .det file (JC)
+fMajorVersion(kvITS04),// Major Version
+fMinorVersion(1),       // Minor Version
+fIgm(kvITS04)          //! Init geometry object
 {
     //
     // Constructor
     //
-    
-    //SetNumberOfSPD(fgkNumberOfSPD);
-    //SetNumberOfSDD(fgkNumberOfSDD);
-    //SetNumberOfSSD(fgkNumberOfSSD);
-    
+
     fIdN = 3;         
     fIdName    = new TString[fIdN];
     fIdName[0] = fgSPDsensitiveVolName;
@@ -147,30 +144,18 @@ fGeomDetIn(kFALSE)
     fIdName[2] = fgSSDsensitiveVolName;
     fIdSens    = new Int_t[fIdN];
     for(Int_t i=0; i<fIdN; i++) fIdSens[i] = 0;
-    
-    //for writing out geometry
-    //fGeomDetOut   = kFALSE; // Don't write .det file
-
-    // for reading in geometry (JC)
-    //fGeomDetIn = kFALSE;
-
     for(Int_t a=0;a<60;a++) fWrite[a] = '\0';    
 }
-
 //__________________________________________________________________
-AliITSvBeamTestITS04::~AliITSvBeamTestITS04()
-{
+AliITSvBeamTestITS04::~AliITSvBeamTestITS04(){
     //
     // Destructor
     //
 }
-
 //______________________________________________________________________
-void AliITSvBeamTestITS04::CreateMaterials()
-{
+void AliITSvBeamTestITS04::CreateMaterials(){
     // Media defined here should correspond to the one defined in galice.cuts
     // This file is read in (AliMC*) fMCApp::Init() { ReadTransPar(); }
-    
     // Create ITS materials
     Int_t   ifield = gAlice->Field()->Integ();
     Float_t fieldm = gAlice->Field()->Max();
@@ -210,9 +195,12 @@ void AliITSvBeamTestITS04::CreateMaterials()
 }
 
 //______________________________________________________________________
-void AliITSvBeamTestITS04::CreateGeometry()
-{    
-  //Creates geometry
+void AliITSvBeamTestITS04::CreateGeometry(){    
+    //Creates geometry
+    // These constant character strings are set by cvs during commit
+    // do not change them unless you know what you are doing!
+    const Char_t *cvsDate="$Date$";
+    const Char_t *cvsRevision="$Revision$";
     TGeoManager *geoManager = gGeoManager;
     TGeoVolume *vALIC = geoManager->GetTopVolume();
     
@@ -224,8 +212,19 @@ void AliITSvBeamTestITS04::CreateGeometry()
     sITS->DefineSection(0,-100.0,0.01,100.0); // Units in cms
     sITS->DefineSection(1,+100.0,0.01,100.0);
     
-    TGeoMedium *air = gGeoManager->GetMedium("ITSair");
-    fITSmotherVolume = new TGeoVolume("vITS",sITS,air);
+    TGeoMedium *air = geoManager->GetMedium("ITSair");
+    fITSmotherVolume = new TGeoVolume("ITSV",sITS,air);
+    const Int_t length=100;
+    Char_t vstrng[length];
+    if(fIgm.WriteVersionString(vstrng,length,(AliITSVersion_t)IsVersion(),
+                               fMinorVersion,cvsDate,cvsRevision))
+        fITSmotherVolume->SetTitle(vstrng);
+    else Error("CreateGeometry","Error writing/setting version string");
+    //printf("Title set to %s\n",vstrng);
+    if(vALIC==0) {
+        Error("CreateGeometry","alic=0");
+        return;
+    } // end if
     fITSmotherVolume->SetVisibility(kFALSE);
     vALIC->AddNode(fITSmotherVolume,1,0);
     
@@ -251,20 +250,23 @@ void AliITSvBeamTestITS04::CreateGeometry()
 void AliITSvBeamTestITS04::Init()
 {
     // Initialize the ITS after it has been created.
-    Int_t i;
-    for(i=0;i<20;i++) printf("*");
-    printf( " ITSbeamtest_Init " );
-    for(i=0;i<20;i++) printf("*"); printf("\n");
-
-//    // Create geometry
-//    if(!fGeomDetIn) this->InitAliITSgeom();
-
-    // Initialize AliITS
+    // Inputs:
+    //   none.
+    // Outputs:
+    //   none.
+    // Return:
+    //   none.
+
+    AliDebug(1,Form("Init: Major version %d Minor version %d",fMajorVersion,
+                 fMinorVersion));
+    //
+    UpdateInternalGeometry();
     AliITS::Init();
-    for(i=0;i<40+16;i++) printf("*"); printf("\n");
+    if(fGeomDetOut) GetITSgeom()->WriteNewFile(fWrite);
 
+    //
 }
-
+/*
 //______________________________________________________________________
 void AliITSvBeamTestITS04::InitAliITSgeom()
 {    
@@ -283,7 +285,7 @@ void AliITSvBeamTestITS04::InitAliITSgeom()
     if (GetITSgeom()) SetITSgeom(0x0);
     AliITSgeom* geom = new AliITSgeom(0,knlayers,nlad,ndet,nModTot);
     SetITSgeom(geom);
-    //*** Set default shapes 
+    // *** Set default shapes 
     const Float_t kDxyzSPD[] = {fgkSPDwidthSens/2, fgkSPDthickSens/2,fgkSPDlengthSens/2};  
     if(!(GetITSgeom()->IsShapeDefined(kSPD)))
        GetITSgeom()->ReSetShape(kSPD,new AliITSgeomSPD425Short(3,(Float_t *)kDxyzSPD));
@@ -366,7 +368,6 @@ void AliITSvBeamTestITS04::InitAliITSgeom()
     
     return;
 }
-
 //______________________________________________________________________
 void AliITSvBeamTestITS04::SetDefaults()
 {
@@ -469,7 +470,7 @@ void AliITSvBeamTestITS04::SetDefaults()
   if(fgkNTYPES>3){Warning("SetDefaults","Only the four basic detector types are initialised!");}
   return;
 }
-
+*/
 //______________________________________________________________________
 void AliITSvBeamTestITS04::AddSPDGeometry(TGeoVolume *moth) const
 {
@@ -573,78 +574,62 @@ void AliITSvBeamTestITS04::StepManager()
     // creator with the information to be recoreded about that hit.
 
     // "Standard" StepManager. (Similar to AliITSv11) mln
-    Int_t copy, id;
+    Int_t cpy0,mod,status,id,kk;
     TLorentzVector position, momentum;
-    static TLorentzVector position0;
-    static Int_t stat0=0;
-    
-    if(!(this->IsActive())){
-       return;
-    } // end if !Active volume.
+    static AliITShit hit;// Saves on calls to construtors
     
+    if(!(this->IsActive())) return;
     if(!(gMC->TrackCharge())) return;
+    //TClonesArray &lhits = *(GetDetTypeSim()->GetHits());
+    TClonesArray &lhits = *(Hits());
+    //
+    // Track status
+    // Track status
+    status = 0;
+    if(gMC->IsTrackInside())      status +=  1;
+    if(gMC->IsTrackEntering())    status +=  2;
+    if(gMC->IsTrackExiting())     status +=  4;
+    if(gMC->IsTrackOut())         status +=  8;
+    if(gMC->IsTrackDisappeared()) status += 16;
+    if(gMC->IsTrackStop())        status += 32;
+    if(gMC->IsTrackAlive())       status += 64;
     
-    id=gMC->CurrentVolID(copy);
+    id=gMC->CurrentVolID(cpy0);
     
     Bool_t sensvol = kFALSE;
-    for(Int_t kk = 0; kk < fIdN; kk++)
-       if(id == fIdSens[kk]) sensvol = kTRUE;
-    
-    if (sensvol && (gMC->IsTrackExiting())) {
-       copy = fTrackReferences->GetEntriesFast();
-       TClonesArray &lTR = *fTrackReferences;
-       // Fill TrackReference structure with this new TrackReference.
-       new(lTR[copy]) AliTrackReference(gAlice->GetMCApp()->GetCurrentTrackNumber());
-    } // if Outer ITS mother Volume
-    
-    Int_t   vol[5];
-    TClonesArray &lhits = *fHits;
+    for(kk=0;kk<fIdN;kk++) if(id == fIdSens[kk]) sensvol = kTRUE;
+    if(!sensvol) return;
+
+    fIgm.DecodeDetector(mod,gGeoManager->GetMother(1)->GetNumber(),1,1,1);
     //
-    // Track status
-    vol[3] = 0;
-    vol[4] = 0;
     // Fill hit structure.
-    if(gMC->IsTrackInside())      vol[3] +=  1;
-    if(gMC->IsTrackEntering())    vol[3] +=  2;
-    if(gMC->IsTrackExiting())     vol[3] +=  4;
-    if(gMC->IsTrackOut())         vol[3] +=  8;
-    if(gMC->IsTrackDisappeared()) vol[3] += 16;
-    if(gMC->IsTrackStop())        vol[3] += 32;
-    if(gMC->IsTrackAlive())       vol[3] += 64;
-    
-    // Only entering charged tracks
-    if(!(gMC->TrackCharge())) return;
-    
-    if( ((id = gMC->CurrentVolID(copy)) == fIdSens[0]) ||
-       ((id = gMC->CurrentVolID(copy)) == fIdSens[1]) ||
-       ((id = gMC->CurrentVolID(copy)) == fIdSens[2]) )
-    {
-       GetCurrentLayLaddDet(vol[0], vol[2], vol[1]);
-       // vol[2], vol[1]) : in this order because the ladder
-       // index and the det. index are exchanged in the constructor
-       // of AliITShit...
-    } else {
-       return; // not an ITS volume?
-    };
-    
+    //
+    hit.SetModule(mod);
+    hit.SetTrack(gAlice->GetMCApp()->GetCurrentTrackNumber());
     gMC->TrackPosition(position);
     gMC->TrackMomentum(momentum);
-    vol[4] = stat0;
+    hit.SetPosition(position);
+    hit.SetTime(gMC->TrackTime());
+    hit.SetMomentum(momentum);
+    hit.SetStatus(status);
+    hit.SetEdep(gMC->Edep());
+    hit.SetShunt(GetIshunt());
     if(gMC->IsTrackEntering()){
-       position0 = position;
-       stat0 = vol[3];
-       return;
+        hit.SetStartPosition(position);
+        hit.SetStartTime(gMC->TrackTime());
+        hit.SetStartStatus(status);
+        return; // don't save entering hit.
     } // end if IsEntering
     // Fill hit structure with this new hit.
-    new(lhits[fNhits++]) AliITShit(fIshunt,gAlice->GetMCApp()->GetCurrentTrackNumber(),
-                                  vol, gMC->Edep(),gMC->TrackTime(),position,
-                                  position0,momentum);
-    //
-    position0 = position;
-    stat0 = vol[3];
+    //Info("StepManager","Calling Copy Constructor");
+    new(lhits[fNhits++]) AliITShit(hit); // Use Copy Construtor.
+    // Save old position... for next hit.
+    hit.SetStartPosition(position);
+    hit.SetStartTime(gMC->TrackTime());
+    hit.SetStartStatus(status);
     return;
 }
-
+/*
 //______________________________________________________________________
 Int_t AliITSvBeamTestITS04::GetCurrentLayLaddDet(Int_t &lay,Int_t &ladd, Int_t &det) const
 { 
@@ -678,7 +663,7 @@ Int_t AliITSvBeamTestITS04::GetCurrentLayLaddDet(Int_t &lay,Int_t &ladd, Int_t &
     
     return kTRUE;
 }
-
+*/
 //_____________________________________________________________
 
  Int_t AliITSvBeamTestITS04::GetNumberOfSubDet(const TString& det) const{
index 7944ebf6e83dd82e81d9dc15311b3ac7325c6ce5..c60e28e648337aba3ddd7a7abeedea9338050d97 100644 (file)
@@ -5,7 +5,7 @@
 // ITS geometry class and step manager for the//
 //   integrated ITS test beam of Nov. 04      //
 ////////////////////////////////////////////////
-
+#include "AliITSInitGeometry.h"
 #include "AliITS.h"
 
 class TGeoVolume;
@@ -13,98 +13,92 @@ class TGeoVolume;
 class AliITSvBeamTestITS04 : public AliITS {
  
  public:
-
-
-  AliITSvBeamTestITS04();
-  AliITSvBeamTestITS04(const char* name,const char *title);
-  virtual ~AliITSvBeamTestITS04();
-
-  virtual void SetNumberOfSPD(Int_t nSPD) {fNspd=nSPD;}
-  virtual void SetNumberOfSDD(Int_t nSDD) {fNsdd=nSDD;}
-  virtual void SetNumberOfSSD(Int_t nSSD) {fNssd=nSSD;}
-
-  Int_t GetNSPD() const {return fNspd;}
-  Int_t GetNSDD() const {return fNsdd;}
-  Int_t GetNSSD() const {return fNssd;}
-
-  Int_t GetNumberOfSubDet(const TString& det) const;
-
-  virtual void CreateGeometry();
-  virtual void CreateMaterials();
-  virtual void InitAliITSgeom();
-  virtual void Init();
-  virtual void SetDefaults();
-  virtual void StepManager();
-  
-  //for writing out geometry
-   virtual void   SetWriteDet(Bool_t det=kTRUE){fGeomDetOut = det;}// set .det write 
-   virtual void   SetWriteDet(const char *f){strncpy(fWrite,f,60);fGeomDetOut = kTRUE;}// set write file 
-
-
-   //for reading geometry (JC)
-    
-  virtual void   SetReadDet(Bool_t det=kTRUE){fGeomDetIn = det;}//set .det read
-  virtual void   SetReadDet(const char *f){strncpy(fRead,f,60);fGeomDetIn = kTRUE;} // set read file
-                                    
-  
- protected:
-  void AddSPDGeometry(TGeoVolume *moth) const;
-  void AddSDDGeometry(TGeoVolume *moth) const;
-  void AddSSDGeometry(TGeoVolume *moth) const;
-  Int_t GetCurrentLayLaddDet(Int_t &lay,Int_t &ladd, Int_t &det) const;
-
-  TGeoVolume *fITSmotherVolume;            //! ITS mother volume
-  static const Int_t fgkNumberOfSPD;       //number of SPD
-  static const Int_t fgkNumberOfSDD;       //number of SDD
-  static const Int_t fgkNumberOfSSD;       //number of SSD
-
-  static const char*    fgSPDsensitiveVolName;  //SPD volume name
-  static const Double_t fgkSPDthickness;        //SPD thickness
-  static const Double_t fgkSPDwidth;            //SPD width
-  static const Double_t fgkSPDlength;           //SPD length
-  static const Double_t fgkSPDthickSens;        //SPD sensitive thickness
-  static const Double_t fgkSPDwidthSens;        //SPD sensitive width
-  static const Double_t fgkSPDlengthSens;       //SPD sensitive length
-  static const Double_t fgkSPD0y;               //SPD position
-  static const Double_t fgkSPD1y;               //SPD position
-
-  static const char*    fgSDDsensitiveVolName;  //SDD volume name
-  static const Double_t fgkSDDthickness;        //SDD thickness
-  static const Double_t fgkSDDwidth;            //SDD width
-  static const Double_t fgkSDDlength;           //SDD length
-  static const Double_t fgkSDDthickSens;        //SDD sensitive thickness
-  static const Double_t fgkSDDwidthSens;        //SDD sensitive width
-  static const Double_t fgkSDDlengthSens;       //SDD sensitive length
-  static const Double_t fgkSDD0y;               //SDD position
-  static const Double_t fgkSDD1y;               //SDD position
-  
-  static const char*    fgSSDsensitiveVolName;   //SSD volume name
-  static const Double_t fgkSSDthickness;         //SSD thickness
-  static const Double_t fgkSSDwidth;             //SSD width
-  static const Double_t fgkSSDlength;            //SSD length
-  static const Double_t fgkSSDthickSens;         //SSD sensitive thickness
-  static const Double_t fgkSSDwidthSens;         //SSD sensitive width
-  static const Double_t fgkSSDlengthSens;        //SSD sensitive length
-  static const Double_t fgkSSD0y;                //SSD position
-  static const Double_t fgkSSD1y;                //SSD position
-
-  Int_t     fNspd;                    //Number of SPD modules
-  Int_t     fNsdd;                    //Number of SDD modules
-  Int_t     fNssd;                    //Number of SSD modules
-
-  //for writing out geometry
-   Bool_t fGeomDetOut;       // Flag to write .det file out 
-   Bool_t fGeomDetIn;        // Flag to read geometry file (JC)
-   char   fWrite[60];        //! file name to write .det file 
-   char   fRead[60];         // file name to read .det file (JC)
-   
+    AliITSvBeamTestITS04();
+    AliITSvBeamTestITS04(const char* name,const char *title);
+    virtual ~AliITSvBeamTestITS04();
+    virtual void SetNumberOfSPD(Int_t nSPD) {fNspd=nSPD;}
+    virtual void SetNumberOfSDD(Int_t nSDD) {fNsdd=nSDD;}
+    virtual void SetNumberOfSSD(Int_t nSSD) {fNssd=nSSD;}
+    Int_t GetNSPD() const {return fNspd;}
+    Int_t GetNSDD() const {return fNsdd;}
+    Int_t GetNSSD() const {return fNssd;}
+    Int_t GetNumberOfSubDet(const TString& det) const;
+    virtual void CreateGeometry();
+    virtual void CreateMaterials();
+    virtual Int_t IsVersion()const{return (Int_t)kvITS04;}//Return Major Version
+    virtual Int_t MinorVersion()const{return fMinorVersion;}//Return Minor Version
+    //virtual void InitAliITSgeom();
+    virtual void Init();
+    //virtual void SetDefaults();
+    virtual void StepManager();
+    //for writing out geometry set .det write 
+    virtual void   SetWriteDet(Bool_t det=kTRUE){fGeomDetOut = det;}
+    virtual void   SetWriteDet(const char *f){strncpy(fWrite,f,60);
+                             fGeomDetOut = kTRUE;}// set write file 
+    //for reading geometry (JC) set .det read
+    virtual void   SetReadDet(Bool_t det=kTRUE){fGeomDetIn = det;}
+    virtual void   SetReadDet(const char *f){strncpy(fRead,f,60);
+                         fGeomDetIn = kTRUE;} // set read file
+ public:
+    void AddSPDGeometry(TGeoVolume *moth) const;
+    void AddSDDGeometry(TGeoVolume *moth) const;
+    void AddSSDGeometry(TGeoVolume *moth) const;
+           //! ITS mother volume
+    static const Int_t fgkNumberOfSPD;       //number of SPD
+    static const Int_t fgkNumberOfSDD;       //number of SDD
+    static const Int_t fgkNumberOfSSD;       //number of SSD
+    // SPD specific
+    static const char*    fgSPDsensitiveVolName;  //SPD volume name
+    static const Double_t fgkSPDthickness;        //SPD thickness
+    static const Double_t fgkSPDwidth;            //SPD width
+    static const Double_t fgkSPDlength;           //SPD length
+    static const Double_t fgkSPDthickSens;        //SPD sensitive thickness
+    static const Double_t fgkSPDwidthSens;        //SPD sensitive width
+    static const Double_t fgkSPDlengthSens;       //SPD sensitive length
+    static const Double_t fgkSPD0y;               //SPD position
+    static const Double_t fgkSPD1y;               //SPD position
+    // SDD specific
+    static const char*    fgSDDsensitiveVolName;  //SDD volume name
+    static const Double_t fgkSDDthickness;        //SDD thickness
+    static const Double_t fgkSDDwidth;            //SDD width
+    static const Double_t fgkSDDlength;           //SDD length
+    static const Double_t fgkSDDthickSens;        //SDD sensitive thickness
+    static const Double_t fgkSDDwidthSens;        //SDD sensitive width
+    static const Double_t fgkSDDlengthSens;       //SDD sensitive length
+    static const Double_t fgkSDD0y;               //SDD position
+    static const Double_t fgkSDD1y;               //SDD position
+    // SDD specific
+    static const char*    fgSSDsensitiveVolName;   //SSD volume name
+    static const Double_t fgkSSDthickness;         //SSD thickness
+    static const Double_t fgkSSDwidth;             //SSD width
+    static const Double_t fgkSSDlength;            //SSD length
+    static const Double_t fgkSSDthickSens;         //SSD sensitive thickness
+    static const Double_t fgkSSDwidthSens;         //SSD sensitive width
+    static const Double_t fgkSSDlengthSens;        //SSD sensitive length
+    static const Double_t fgkSSD0y;                //SSD position
+    static const Double_t fgkSSD1y;                //SSD position
+    //
  private:
-   AliITSvBeamTestITS04(const AliITSvBeamTestITS04 &source); // Copy constructor
-   AliITSvBeamTestITS04& operator=(const AliITSvBeamTestITS04 &source); // = operator
-
-   ClassDef(AliITSvBeamTestITS04,2) 
-
- };
+    //Int_t GetCurrentLayLaddDet(Int_t &lay,Int_t &ladd, Int_t &det) const;:
+    AliITSvBeamTestITS04(const AliITSvBeamTestITS04 &source);//Copy constructor
+    //=operator
+    AliITSvBeamTestITS04& operator=(const AliITSvBeamTestITS04 &source);
+    //
+    TGeoVolume *fITSmotherVolume; 
+    Int_t     fNspd;                    //Number of SPD modules
+    Int_t     fNsdd;                    //Number of SDD modules
+    Int_t     fNssd;                    //Number of SSD modules
+    //for writing out geometry
+    Bool_t fGeomDetOut;       // Flag to write .det file out 
+    Bool_t fGeomDetIn;        // Flag to read geometry file (JC)
+    char   fWrite[60];        //! file name to write .det file 
+    char   fRead[60];         // file name to read .det file (JC)
+    AliITSVersion_t fMajorVersion; // Major Version
+    Int_t           fMinorVersion; // Minor Version
+    AliITSInitGeometry fIgm; //! Init geometry object
+
+    ClassDef(AliITSvBeamTestITS04,3) // Full ITS test beam geometry 2004
+};
 
 #endif
 
index 3e9e762879a2f005415152ada27e89945da07784..c1147c87b0985dbfbb8300c1f65a0611e0d7c38d 100644 (file)
 ClassImp(AliITSvPPRasymmFMD)
  
 //______________________________________________________________________
-AliITSvPPRasymmFMD::AliITSvPPRasymmFMD(): AliITS(),
-fGeomDetOut(kFALSE),
-fGeomDetIn(kFALSE),
-fByThick(kTRUE),
-fMajorVersion(IsVersion()),
-fMinorVersion(-1),
-fDet1(0),
-fDet2(0),
-fChip1(0),
-fChip2(0),
-fRails(0),
-fFluid(0),
-fIDMother(0)
+AliITSvPPRasymmFMD::AliITSvPPRasymmFMD():
+AliITS(),                    // Default AliITS Constructor
+fGeomDetOut(kFALSE),         // Flag to write .det file out
+fGeomDetIn(kFALSE),          // Flag to read .det file or directly from Geat.
+fByThick(kTRUE),             // Flag to use services materials by thickness
+                             // ture, or mass false.
+fMajorVersion(IsVersion()),  // Major version number == IsVersion
+fMinorVersion(2),           // Minor version number
+fEuclidGeomDet("$ALICE_ROOT/ITS/ITSgeometry_vPPRasymm2.det"),// file where detector transormation are define.
+fRead("$ALICE_ROOT/ITS/ITSgeometry_vPPRasymm.det"),//! file name to read .det file
+fWrite("$ALICE_ROOT/ITS/ITSgeometry_vPPRasymm2.det"),//! file name to write .det file
+fDet1(200.0),     // thickness of detector in SPD layer 1 [microns]
+fDet2(200.0),     // thickness of detector in SPD layer 2 [microns]
+fChip1(150.0),    // thickness of chip in SPD layer 1 [microns]
+fChip2(150.0),    // thickness of chip in SPD layer 2 [microns]
+fRails(0),         // flag to switch rails on (=1) and off (=0)
+fFluid(1),         // flag to switch between water (=1)& freon (=0)
+fIDMother(0),      //! ITS Mother Volume id.
+fIgm((AliITSVersion_t)fMajorVersion,fMinorVersion)//! Get access to decoding 
+                                               // and AliITSgeom init functions
  {
     //    Standard default constructor for the ITS version 10.
     // Inputs:
@@ -91,27 +98,79 @@ fIDMother(0)
     //   none.
     // Return:
     //   none.
+    fIgm.SetGeometryName("");
+}
+//______________________________________________________________________
+AliITSvPPRasymmFMD::AliITSvPPRasymmFMD(const Char_t *title):
+AliITS(title),               // Standard AliITS Constructor
+fGeomDetOut(kFALSE),         // Flag to write .det file out
+fGeomDetIn(kFALSE),          // Flag to read .det file or directly from Geat.
+fByThick(kTRUE),             // Flag to use services materials by thickness
+                             // ture, or mass false.
+fMajorVersion(IsVersion()),  // Major version number == IsVersion
+fMinorVersion(2),            // Minor version number
+fEuclidGeomDet("$ALICE_ROOT/ITS/ITSgeometry_vPPRasymm2.det"),// file where detector transormation are define.
+fRead("$ALICE_ROOT/ITS/ITSgeometry_vPPRasymm.det"),//! file name to read .det file
+fWrite("$ALICE_ROOT/ITS/ITSgeometry_vPPRasymm2.det"),//! file name to write .det file
+fDet1(200.0),     // thickness of detector in SPD layer 1 [microns]
+fDet2(200.0),     // thickness of detector in SPD layer 2 [microns]
+fChip1(150.0),    // thickness of chip in SPD layer 1 [microns]
+fChip2(150.0),    // thickness of chip in SPD layer 2 [microns]
+fRails(0),         // flag to switch rails on (=1) and off (=0)
+fFluid(1),         // flag to switch between water (=1)& freon (=0)
+fIDMother(0),      //! ITS Mother Volume id.
+fIgm((AliITSVersion_t)fMajorVersion,fMinorVersion)//! Get access to decoding 
+                                               // and AliITSgeom init functions
+{
+    //    Standard constructor for the ITS version 10.
+    // Inputs:
+    //   const Char_t * title  Arbitrary title
+    // Outputs:
+    //   none.
+    // Return:
+    //   none.
     Int_t i;
-    for(i=0;i<60;i++) fRead[i] = '\0';
-    for(i=0;i<60;i++) fWrite[i] = '\0';
-    for(i=0;i<60;i++) fEuclidGeomDet[i] = '\0';
-    strncpy(fRead,"$ALICE_ROOT/ITS/ITSgeometry_vPPRasymmFMD.det",60);
+
+    fIgm.SetDecoding(kFALSE);// Use Alice compliant naming/numbering system
+    fIgm.SetTiming(kFALSE);// default no timing
+    fIgm.SetSegGeom(kFALSE);// use AliITSgeomS?D classes instead 
+                            // of segmentation AliITSsegmentationS?D class
+    fIgm.SetGeometryName("ITS PPR aymmetric services with course"
+                         " cables on cones");
+    // Set some AliITS class veriables.
+    fIdN = 6;
+    fIdName = new TString[fIdN];
+    fIdName[0] = "ITS1";
+    fIdName[1] = "ITS2";
+    fIdName[2] = "ITS3";
+    fIdName[3] = "ITS4";
+    fIdName[4] = "ITS5";
+    fIdName[5] = "ITS6";
+    fIdSens    = new Int_t[fIdN];
+    for(i=0;i<fIdN;i++) fIdSens[i] = 0;
 }
 //______________________________________________________________________
-AliITSvPPRasymmFMD::AliITSvPPRasymmFMD(const char *name, const char *title) 
-  : AliITS("ITS", title),
-    fGeomDetOut(kFALSE),
-    fGeomDetIn(kFALSE),
-    fByThick(kTRUE),
-    fMajorVersion(IsVersion()),
-    fMinorVersion(2),
-    fDet1(0),
-    fDet2(0),
-    fChip1(0),
-    fChip2(0),
-    fRails(0),
-    fFluid(0),
-    fIDMother(0) {
+AliITSvPPRasymmFMD::AliITSvPPRasymmFMD(const char *name, const char *title):
+AliITS(name,title),          // Extended AliITS Constructor
+fGeomDetOut(kFALSE),         // Flag to write .det file out
+fGeomDetIn(kFALSE),          // Flag to read .det file or directly from Geat.
+fByThick(kTRUE),             // Flag to use services materials by thickness
+                             // ture, or mass false.
+fMajorVersion(IsVersion()),  // Major version number == IsVersion
+fMinorVersion(2),            // Minor version number
+fEuclidGeomDet("$ALICE_ROOT/ITS/ITSgeometry_vPPRasymm2.det"),// file where detector transormation are define.
+fRead("$ALICE_ROOT/ITS/ITSgeometry_vPPRasymm.det"),//! file name to read .det file
+fWrite("$ALICE_ROOT/ITS/ITSgeometry_vPPRasymm2.det"),//! file name to write .det file
+fDet1(200.0),     // thickness of detector in SPD layer 1 [microns]
+fDet2(200.0),     // thickness of detector in SPD layer 2 [microns]
+fChip1(150.0),    // thickness of chip in SPD layer 1 [microns]
+fChip2(150.0),    // thickness of chip in SPD layer 2 [microns]
+fRails(0),         // flag to switch rails on (=1) and off (=0)
+fFluid(1),         // flag to switch between water (=1)& freon (=0)
+fIDMother(0),      //! ITS Mother Volume id.
+fIgm((AliITSVersion_t)fMajorVersion,fMinorVersion)//! Get access to decoding 
+                                               // and AliITSgeom init functions
+{
     //    Standard constructor for the ITS version 10.
     // Inputs:
     //   const char * name   Ignored, set to "ITS"
@@ -120,11 +179,18 @@ AliITSvPPRasymmFMD::AliITSvPPRasymmFMD(const char *name, const char *title)
     //   none.
     // Return:
     //   none.
+
     Int_t i;
 
+    fIgm.SetDecoding(kFALSE);// Use Alice compliant naming/numbering system
+    fIgm.SetTiming(kFALSE);// default no timing
+    fIgm.SetSegGeom(kFALSE);// use AliITSgeomS?D classes instead 
+                            // of segmentation AliITSsegmentationS?D class
+    fIgm.SetGeometryName("ITS PPR aymmetric services with course"
+                         " cables on cones");
+    // Set some AliITS class veriables.
     fIdN = 6;
     fIdName = new TString[fIdN];
-    fIdName[0] = name; // removes warning message
     fIdName[0] = "ITS1";
     fIdName[1] = "ITS2";
     fIdName[2] = "ITS3";
@@ -133,17 +199,68 @@ AliITSvPPRasymmFMD::AliITSvPPRasymmFMD(const char *name, const char *title)
     fIdName[5] = "ITS6";
     fIdSens    = new Int_t[fIdN];
     for(i=0;i<fIdN;i++) fIdSens[i] = 0;
+
     SetThicknessDet1();
     SetThicknessDet2();
     SetThicknessChip1();
     SetThicknessChip2();
     SetDensityServicesByThickness();
+}
+//______________________________________________________________________
+AliITSvPPRasymmFMD::AliITSvPPRasymmFMD(const AliITSvPPRasymmFMD &source):
+AliITS(source.GetName(),source.GetTitle()),// Extended AliITS Constructor
+fGeomDetOut(source.GetWriteDet()),// Flag to write .det file out
+fGeomDetIn(source.GetReadDet()),  // Flag to read .det file or directly 
+                                  // from Geat.
+fByThick(source.IsDensityServicesByThickness()),// Flag to use services 
+                                                // materials by thickness
+                                                // ture, or mass false.
+fMajorVersion(source.IsVersion()),  // Major version number == IsVersion
+fMinorVersion(source.GetMinorVersion()),// Minor version number
+fEuclidGeomDet(source.GetEuclidFile()),// file where detector transormation 
+                                       // are define.
+fRead(source.GetReadDetFileName()),  //! file name to read .det file
+fWrite(source.GetWriteDetFileName()),//! file name to write .det file
+fDet1(source.GetThicknessDet1()),//thickness of detector in SPD layer 1[micron]
+fDet2(source.GetThicknessDet2()),//thickness of detector in SPD layer 2[micron]
+fChip1(source.GetThicknessChip1()),//thickness of chip in SPD layer 1 [microns]
+fChip2(source.GetThicknessChip2()),//thickness of chip in SPD layer 2 [microns]
+fRails(source.GetRails()),         // flag to switch rails on (=1) and off (=0)
+fFluid(source.GetCoolingFluid()),// flag to switch between water (1)& freon (0)
+fIDMother(source.GetMotherID()),      //! ITS Mother Volume id.
+fIgm(source.GetGeomInit())//! Get access to decoding 
+                          // and AliITSgeom init functions
+{
+    //     Copy Constructor for ITS version 10. This function is not to be
+    // used. If any other instance of this function, other than "this" is
+    // passed, an error message is returned.
+    // Inputs:
+    //   const AliITSvPPRasymmFMD &source This class
+    // Outputs:
+    //   none.
+    // Return:
+    //   an error message
+
+    if(&source == this) return;
+    Warning("Copy Constructor","Not allowed to copy AliITSvPPRasymmFMD");
+    return;
+}
+//______________________________________________________________________
+AliITSvPPRasymmFMD& AliITSvPPRasymmFMD::operator=(const AliITSvPPRasymmFMD 
+                                                 &source){
+    //    Assignment operator for the ITS version 10. This function is not 
+    // to be used. If any other instance of this function, other than "this" 
+    // is passed, an error message is returned.
+    // Inputs:
+    //   const AliITSvPPRasymmFMD &source This class
+    // Outputs:
+    //   none.
+    // Return:
+    //   an error message
 
-    fEuclidGeometry="$ALICE_ROOT/ITS/ITSgeometry_vPPRasymm2.euc";
-    strncpy(fEuclidGeomDet,"$ALICE_ROOT/ITS/ITSgeometry_vPPRasymm2.det",60);
-    strncpy(fRead,fEuclidGeomDet,60);
-    strncpy(fWrite,fEuclidGeomDet,60);
-    strncpy(fRead,"$ALICE_ROOT/ITS/ITSgeometry_vPPRasymmFMD.det",60);
+    if(&source == this) return *this;
+    Warning("= operator","Not allowed to copy AliITSvPPRasymmFMD");
+    return *this; // return null pointer, copy not allowed.
 }
 //______________________________________________________________________
 AliITSvPPRasymmFMD::~AliITSvPPRasymmFMD() {
@@ -718,6 +835,11 @@ void AliITSvPPRasymmFMD::CreateGeometry(){
 
     Float_t dbus=300.;      // total bus thickness on both layers (micron)
 
+    // These constant character strings are set by cvs during commit
+    // do not change them unless you know what you are doing!
+    const Char_t *cvsDate="$Date$";
+    const Char_t *cvsRevision="$Revision$";
+
     ddet1 = GetThicknessDet1();
     ddet2 = GetThicknessDet2();
     dchip1 = GetThicknessChip1();
@@ -1296,64 +1418,76 @@ void AliITSvPPRasymmFMD::CreateGeometry(){
     ztpc = 284.;
     // --- Define ghost volume containing the whole ITS (including services) 
     //     and fill it with air
-    dgh[0] = 0.;
-    dgh[1] = 360.;
-    dgh[2] = 16.;
-    dgh[3] = -ztpc-5.-0.1;
-    dgh[4] = 46;   
-    dgh[5] = 85.;
-    dgh[6] = -ztpc;
-    dgh[7] = 46;   
-    dgh[8] = 85.;
-    dgh[9] = -ztpc;
-    dgh[10] = 46;  
-    dgh[11] = rlim+7.5;
-    dgh[12] = -97.5;
-    dgh[13] = 46;  
-    dgh[14] = rlim+7.5;
-    dgh[15] = -zmax;
-    dgh[16] = 46;  
-    dgh[17] = rlim+7.5;
-    dgh[18] = -48;   
-    dgh[19] = 6;
-    dgh[20] = rlim+7.5;
-    dgh[21] = -28.6;   
-    dgh[22] = 6;
-    dgh[23] = rlim+7.5;    
-    dgh[24] = -27.6;  
-    dgh[25] = 3.295;
-    dgh[26] = rlim+7.5; 
-    dgh[27] = 27.6;   
-    dgh[28] = 3.295;
-    dgh[29] = rlim+7.5;
-    dgh[30] = 28.6;   
-    dgh[31] = 6;
-    dgh[32] = rlim+7.5;
-    dgh[33] = 48;   
-    dgh[34] = 6;
-    dgh[35] = rlim+7.5;  
-    dgh[36] = zmax;
-    dgh[37] = 46;
-    dgh[38] = rlim+7.5;
-    dgh[39] = 97.5;
-    dgh[40] = 46;  
-    dgh[41] = rlim+7.5;
-    dgh[42] = ztpc;
-    dgh[43] = 62;     
-    dgh[44] = 62+4.;  
-    dgh[45] = ztpc;
-    dgh[46] = 62;     
-    dgh[47] = 85.;
-    dgh[48] = ztpc+4.+0.1;
-    dgh[49] = 62.0;//62.4;
-    dgh[50] = 85.;
-    gMC->Gsvolu("ITSV", "PCON", idtmed[205], dgh, 51);
 
+//     dgh[0] = 0.;
+//     dgh[1] = 360.;
+//     dgh[2] = 16.;
+//     dgh[3] = -ztpc-5.-0.1;
+//     dgh[4] = 46;   
+//     dgh[5] = 85.;
+//     dgh[6] = -ztpc;
+//     dgh[7] = 46;   
+//     dgh[8] = 85.;
+//     dgh[9] = -ztpc;
+//     dgh[10] = 46;  
+//     dgh[11] = rlim+7.5;
+//     dgh[12] = -97.5;
+//     dgh[13] = 46;  
+//     dgh[14] = rlim+7.5;
+//     dgh[15] = -zmax;
+//     dgh[16] = 46;  
+//     dgh[17] = rlim+7.5;
+//     dgh[18] = -48;   
+//     dgh[19] = 6;
+//     dgh[20] = rlim+7.5;
+//     dgh[21] = -28.6;   
+//     dgh[22] = 6;
+//     dgh[23] = rlim+7.5;    
+//     dgh[24] = -27.6;  
+//     dgh[25] = 3.295;
+//     dgh[26] = rlim+7.5; 
+//     dgh[27] = 27.6;   
+//     dgh[28] = 3.295;
+//     dgh[29] = rlim+7.5;
+//     dgh[30] = 28.6;   
+//     dgh[31] = 6;
+//     dgh[32] = rlim+7.5;
+//     dgh[33] = 48;   
+//     dgh[34] = 6;
+//     dgh[35] = rlim+7.5;  
+//     dgh[36] = zmax;
+//     dgh[37] = 46;
+//     dgh[38] = rlim+7.5;
+//     dgh[39] = 97.5;
+//     dgh[40] = 46;  
+//     dgh[41] = rlim+7.5;
+//     dgh[42] = ztpc;
+//     dgh[43] = 62;     
+//     dgh[44] = 62+4.;  
+//     dgh[45] = ztpc;
+//     dgh[46] = 62;     
+//     dgh[47] = 85.;
+//     dgh[48] = ztpc+4.+0.1;
+//     dgh[49] = 62.0;//62.4;
+//     dgh[50] = 85.;
+//     gMC->Gsvolu("ITSV", "PCON", idtmed[205], dgh, 51);
+    TGeoVolumeAssembly *itsV = gGeoManager->MakeVolumeAssembly("ITSV");
+    const Int_t length=100;
+    Char_t vstrng[length];
+    if(fIgm.WriteVersionString(vstrng,length,(AliITSVersion_t)IsVersion(),
+                               fMinorVersion,cvsDate,cvsRevision))
+      itsV->SetTitle(vstrng);
+    
     // --- Place the ghost volume in its mother volume (ALIC) and make it 
     //     invisible
-    //    gMC->Gspos("ITSV", 1, "ALIC", 0., 0., 0., 0, "ONLY");
-    gMC->Gspos("ITSV", 1, "ALIC", 0., 0., 0., idrotm[199], "MANY");
-    //gMC->Gsatt("ITSV", "SEEN", 0);
+    //    gMC->Gspos("ITSV", 1, "ALIC", 0., 0., 0., idrotm[199], "MANY");
+    TGeoVolume *alic = gGeoManager->GetVolume("ALIC");
+    if(alic==0) {
+        Error("CreateGeometry","alic=0");
+        return;
+    } // end if
+    // See idrotm[199] for angle definitions.
+    alic->AddNode(itsV,1,new TGeoRotation("", 90.,180., 90.,90., 180.,0.));
 
     // --- Define ghost volume containing the six layers and fill it with air 
   
@@ -5930,6 +6064,7 @@ void AliITSvPPRasymmFMD::DrawModule() const{
     gMC->Gdhead(1111, "Inner Tracking System Version 1");
     gMC->Gdman(17, 6, "MAN");
 }
+/*
 //______________________________________________________________________
 void AliITSvPPRasymmFMD::StepManager(){
     //    Called for every step in the ITS, then calles the AliITShit class
@@ -6063,3 +6198,258 @@ void AliITSvPPRasymmFMD::StepManager(){
 
     return;
 }
+
+*/
+//______________________________________________________________________
+void AliITSvPPRasymmFMD::StepManager(){
+    //    Called for every step in the ITS, then calles the AliITShit class
+    // creator with the information to be recoreded about that hit.
+    //     The value of the macro ALIITSPRINTGEOM if set to 1 will allow the
+    // printing of information to a file which can be used to create a .det
+    // file read in by the routine CreateGeometry(). If set to 0 or any other
+    // value except 1, the default behavior, then no such file is created nor
+    // it the extra variables and the like used in the printing allocated.
+    // Inputs:
+    //   none.
+    // Outputs:
+    //   none.
+    // Return:
+    //   none.
+
+    if(!(this->IsActive())) return;
+    if(!(gMC->TrackCharge())) return;
+
+    Int_t  copy, id,kk;
+    Bool_t sensvol = kFALSE;
+
+    id = gMC->CurrentVolID(copy);
+    for(kk=0;kk<fIdN;kk++)if(id == fIdSens[kk]){
+        sensvol=kTRUE;
+        break;
+    } // end for if
+    if(sensvol && (gMC->IsTrackExiting())){
+        copy = fTrackReferences->GetEntriesFast();
+        TClonesArray &lTR = *fTrackReferences;
+        // Fill TrackReference structure with this new TrackReference.
+        new(lTR[copy]) AliTrackReference(
+            gAlice->GetMCApp()->GetCurrentTrackNumber());
+    } // if Outer ITS mother Volume
+    //if(!sensvol) return; // not an ITS tracking volume;
+
+    static TLorentzVector position, momentum; // Saves on calls to construtors
+    static AliITShit hit;// Saves on calls to construtors
+    Int_t   cpn0,cpn1,cpn2,status,mod;
+    //TClonesArray &lhits = *(GetDetTypeSim()->GetHits());
+    TClonesArray &lhits = *(Hits());
+    //
+    // Track status
+    status = 0;
+    if(gMC->IsTrackInside())      status +=  1;
+    if(gMC->IsTrackEntering())    status +=  2;
+    if(gMC->IsTrackExiting())     status +=  4;
+    if(gMC->IsTrackOut())         status +=  8;
+    if(gMC->IsTrackDisappeared()) status += 16;
+    if(gMC->IsTrackStop())        status += 32;
+    if(gMC->IsTrackAlive())       status += 64;
+    //
+    switch (kk){
+    case 0:case 1: // SPD
+        gMC->CurrentVolOffID(2,cpn2);
+        gMC->CurrentVolOffID(3,cpn1);
+        gMC->CurrentVolOffID(4,cpn0);
+        break;
+    case 2:case 3: // SDD
+        cpn2 = 1;
+        gMC->CurrentVolOffID(1,cpn1);
+        gMC->CurrentVolOffID(2,cpn0);
+        break;
+    case 4:case 5: // SSD
+        cpn2 = 1;
+        gMC->CurrentVolOffID(1,cpn1);
+        gMC->CurrentVolOffID(2,cpn0);
+        break;
+    default:
+        Error("StepManager","Unknown volume kk=%d",kk);
+        return; // not an ITS sensitive volume.
+    } //
+    fIgm.DecodeDetector(mod,kk+1,cpn0,cpn1,cpn2);
+    //Info("StepManager","lay=%d mod=%d cpn0=%d cpn1=%d cpn2=%d",kk+1,mod,cpn0,cpn1,cpn2);
+    Int_t lay,lad,det,cpy0,cpy1,cpy2;
+    fIgm.DecodeDetectorLayers(mod,lay,lad,det);
+    fIgm.RecodeDetector(mod,cpy0,cpy1,cpy2);
+    printf("gMC: kk=%d cpn0=%d cpn1=%d cpn2=%d -> mod=%d -> "
+           "lay=%d lad=%d det=%d -> cpn0=%d cpn1=%d cpn2=%d\n",
+           kk,cpn0,cpn1,cpn2,mod,lay,lad,det,cpy0,cpy1,cpy2);
+    //
+    // Fill hit structure.
+    //
+    hit.SetModule(mod);
+    hit.SetTrack(gAlice->GetMCApp()->GetCurrentTrackNumber());
+    gMC->TrackPosition(position);
+    gMC->TrackMomentum(momentum);
+    hit.SetPosition(position);
+    hit.SetTime(gMC->TrackTime());
+    hit.SetMomentum(momentum);
+    hit.SetStatus(status);
+    hit.SetEdep(gMC->Edep());
+    hit.SetShunt(GetIshunt());
+    if(gMC->IsTrackEntering()){
+        hit.SetStartPosition(position);
+        hit.SetStartTime(gMC->TrackTime());
+        hit.SetStartStatus(status);
+        return; // don't save entering hit.
+    } // end if IsEntering
+    // Fill hit structure with this new hit.
+    //Info("StepManager","Calling Copy Constructor");
+    new(lhits[fNhits++]) AliITShit(hit); // Use Copy Construtor.
+    // Save old position... for next hit.
+    hit.SetStartPosition(position);
+    hit.SetStartTime(gMC->TrackTime());
+    hit.SetStartStatus(status);
+    //
+    /*
+    Int_t idettype,ix,iz;
+    Float_t lx,lz;
+    Double_t g0[4],l0[4],g1[4];
+    position.GetXYZT(g0);
+    gMC->Gmtod(g0,l0,1); // flag=1 convert coordiantes
+    gMC->Gdtom(l0,g1,1); // flag=1 convert coordinates
+    switch(idettype=(Int_t)GetITSgeom()->GetModuleType(mod)){
+    case kSPD:
+        AliITSsegmentationSPD *segspd = (AliITSsegmentationSPD *)GetSegmentationModelByModule(mod);
+        segspd->LocalToDet((Float_t)l0[0],(Float_t)l0[2],ix,iz);
+        segspd->DetToLocal(ix,iz,lx,lz);
+        break;
+    case kSDD:
+        AliITSsegmentationSDD *segsdd = (AliITSsegmentationSDD *)GetSegmentationModelByModule(mod);
+        segsdd->LocalToDet((Float_t)l0[0],(Float_t)l0[2],ix,iz);
+        segsdd->DetToLocal(ix,iz,lx,lz);
+        break;
+    case kSSD:
+        AliITSsegmentationSSD *segssd = (AliITSsegmentationSSD *)GetSegmentationModelByModule(mod);
+        segssd->LocalToDet((Float_t)l0[0],(Float_t)l0[2],ix,iz);
+        segssd->DetToLocal(ix,iz,lx,lz);
+        break;
+    default:
+        ix = iz = -1;
+        lx = lz = 0.0;
+        Warning("StepManager","Unknown module type id=%d mod=%d",
+                (Int_t)(GetITSgeom()->GetModuleType(mod)),mod);
+    } // end if
+    printf("    gMC: mod=%d g=%g %g %g %g -> "
+                           "l=%g %g %g %g -> "
+                           "g=%g %g %g %g -> "
+                           "ix=%d iz=%d -> lx=%g lz=%g\n",
+           mod,g0[0],g0[1],g0[2],g0[3],
+               l0[0],l0[1],l0[2],l0[3],
+               g1[0],g1[1],g1[2],g1[3],ix,iz,lx,lz);
+    GetITSgeom()->GtoL(mod,g0,l0);
+    GetITSgeom()->LtoG(mod,l0,g1);
+    printf("ITSgeom: mod=%d g=%g %g %g %g -> "
+                           "l=%g %g %g %g -> "
+                           "g=%g %g %g %g -> "
+                           "ix=%d iz=%d -> lx=%g lz=%g\n",
+           mod,g0[0],g0[1],g0[2],g0[3],
+               l0[0],l0[1],l0[2],l0[3],
+               g1[0],g1[1],g1[2],g1[3],ix,iz,lx,lz);
+    TGeoNode *cur = gGeoManager->GetCurrentNode();
+    cur->MasterToLocal(g0,l0);
+    cur->LocalToMaster(l0,g1);
+    printf("   TGeo: mod=%d g=%g %g %g %g -> "
+                           "l=%g %g %g %g -> "
+                           "g=%g %g %g %g\n",
+           mod,g0[0],g0[1],g0[2],g0[3],
+               l0[0],l0[1],l0[2],l0[3],
+               g1[0],g1[1],g1[2],g1[3]);
+    printf("=====================\n");
+    //
+    */
+    return;
+}
+//______________________________________________________________________
+void AliITSvPPRasymmFMD::PrintAscii(ostream *os)const{
+    // Print out class data values in Ascii Form to output stream
+    // Inputs:
+    //   ostream *os   Output stream where Ascii data is to be writen
+    // Outputs:
+    //   none.
+    // Return:
+    //   none.
+#if defined __GNUC__
+#if __GNUC__ > 2
+    ios::fmtflags fmt;
+#else
+    Int_t fmt;
+#endif
+#else
+#if defined __ICC || defined __ECC || defined __xlC__
+    ios::fmtflags fmt;
+#else
+    Int_t fmt;
+#endif
+#endif
+
+    *os << fGeomDetOut << " " << fGeomDetIn << " " << fByThick << " ";
+    *os << fMajorVersion << " " << fMinorVersion << " ";
+    *os << "\"" << fEuclidGeomDet.Data() << "\"" << " ";
+    *os << "\"" << fRead.Data() << "\"" << " ";
+    *os << "\"" << fWrite.Data() << "\"" << " ";
+    fmt = os->setf(ios::scientific); // set scientific floating point output
+    *os << fDet1 << " "  << fDet2 << " " << fChip1 << " " << fChip2 << " ";
+    *os << fRails << " " << fFluid << " " << fIDMother;
+    os->flags(fmt); // reset back to old Formating.
+    return;
+}
+//______________________________________________________________________
+void AliITSvPPRasymmFMD::ReadAscii(istream *is){
+    // Read in class data values in Ascii Form to output stream
+    // Inputs:
+    //   istream *is   Input stream where Ascii data is to be read in from
+    // Outputs:
+    //   none.
+    // Return:
+    //   none.
+    Char_t name[120];
+
+    *is >> fGeomDetOut >> fGeomDetIn >> fByThick;
+    *is >> fMajorVersion >> fMinorVersion;
+    *is >> name;
+    fEuclidGeomDet = name;
+    *is >> name;
+    fRead = name;
+    *is >> name;
+    fWrite = name;
+    *is >> fDet1 >> fDet2 >> fChip1 >> fChip2;
+    *is >> fRails >> fFluid >> fIDMother;
+    fIgm.SetVersion((AliITSVersion_t)fMajorVersion,fMinorVersion);
+    fIgm.SetGeometryName("ITS PPR aymmetric services with course"
+                         " cables on cones");
+}
+//______________________________________________________________________
+ostream &operator<<(ostream &os,const AliITSvPPRasymmFMD &s){
+    // Standard output streaming function
+    // Inputs:
+    //   ostream            &os  output steam
+    //   AliITSvPPRasymmFMD &s class to be streamed.
+    // Output:
+    //   none.
+    // Return:
+    //   ostream &os  The stream pointer
+
+    s.PrintAscii(&os);
+    return os;
+}
+//______________________________________________________________________
+istream &operator>>(istream &is,AliITSvPPRasymmFMD &s){
+    // Standard inputput streaming function
+    // Inputs:
+    //   istream            &is  input steam
+    //   AliITSvPPRasymmFMD &s class to be streamed.
+    // Output:
+    //   none.
+    // Return:
+    //   ostream &os  The stream pointer
+
+    s.ReadAscii(&is);
+    return is;
+}
index ad95bb68b56e28bdf9079ee7080963ecda797ec2..3c4d4ac59b4ada8c6a0e7d8185849d211a986e44 100644 (file)
 /////////////////////////////////////////////////////////
  
 #include "AliITS.h"
+#include "AliITSInitGeometry.h"
+
 class AliITSvPPRasymmFMD : public AliITS {
 
  public:
     AliITSvPPRasymmFMD();
+    AliITSvPPRasymmFMD(const Char_t *title); // Standard Constructor
+    // Extended Standard constructor
     AliITSvPPRasymmFMD(const char *name, const char *title);
     virtual       ~AliITSvPPRasymmFMD() ;
     virtual void   BuildGeometry();
@@ -27,16 +30,17 @@ class AliITSvPPRasymmFMD : public AliITS {
     virtual void   DrawModule() const;
     virtual void   StepManager();
     virtual void   AddAlignableVolumes() const;
-    virtual void   SetWriteDet(Bool_t det=kFALSE){ // set .det write
-                                                fGeomDetOut = det;}
-    virtual void   SetWriteDet(const char *f){ // set write file
-                                    strncpy(fWrite,f,60);fGeomDetOut = kTRUE;}
-    virtual void   SetReadDet(Bool_t det=kFALSE){ //set .det read
-                                               fGeomDetIn = det;}
-    virtual void   SetReadDet(const char *f){ // set read file
-                                      strncpy(fRead,f,60);fGeomDetIn = kTRUE;}
-    virtual void   SetEUCLIDFileName(const char *f){ // set write file
-                            fEuclidGeometry=f; SetEUCLID();}
+    //set .det write
+    virtual void  SetWriteDet(Bool_t det=kFALSE){fGeomDetOut=det;}
+    // set write file
+    virtual void   SetWriteDet(const Char_t *f){fWrite=f;fGeomDetOut=kTRUE;}
+    //set .det read
+    virtual void   SetReadDet(Bool_t det=kFALSE){fGeomDetIn = det;}
+    // set read file
+    virtual void   SetReadDet(const Char_t *f){fRead=f;fGeomDetIn=kTRUE;}
+    // set write file
+    virtual void   SetEUCLIDFileName(const Char_t *f){fEuclidGeometry=f;
+                                                          SetEUCLID();}
     virtual void   SetMinorVersion(Int_t v=2){ // Choose between existing minor versions
        fMinorVersion = v;}
     virtual void   SetThicknessDet1(Float_t v=200.){ 
@@ -63,16 +67,18 @@ class AliITSvPPRasymmFMD : public AliITS {
     virtual void SetDensityServicesByMass(){// uses services density
        // calculation based on the Mass of the services.
        fByThick = kFALSE;}
-    virtual const char  *GetEULIIDFileName() const{ // return .euc file name
-                                      return fEuclidGeometry.Data();}
-    virtual Bool_t GetWriteDet() const { // returns value GeomDetOut flag.
-                                 return fGeomDetOut;}
-    virtual Bool_t GetReadDet() const { // returns value GeomDetIn flag.
-                                return fGeomDetIn;}
-    virtual char  *GetReadDetFileName(){ // return .det read file name
-                 if(fRead[0]!='\0') return fRead; else return fEuclidGeomDet;}
-    virtual char  *GetWriteDetFileName(){ // return .det write file name
-               if(fWrite[0]!='\0') return fWrite; else return fEuclidGeomDet;}
+    virtual const Char_t *GetEULIIDFileName() const{ // return .euc file name
+        return fEuclidGeometry.Data();}
+    // returns value GeomDetOut flag.
+    virtual Bool_t GetWriteDet() const {return fGeomDetOut;}
+    // returns value GeomDetIn flag.
+    virtual Bool_t GetReadDet() const{return fGeomDetIn;} 
+    virtual const Char_t *GetReadDetFileName()const{//return .det read file name
+        if(fRead.IsNull()) return fRead.Data();
+        else return GetEULIIDFileName();}
+    virtual const Char_t *GetWriteDetFileName()const{//return .det write file name
+        if(fWrite.IsNull()) return fWrite.Data();
+        else return GetEULIIDFileName();}
     virtual Int_t GetMajorVersion() const {// return Major Version Number
        return fMajorVersion;}
     virtual Int_t GetMinorVersion() const {// return Major Version Number
@@ -95,32 +101,50 @@ class AliITSvPPRasymmFMD : public AliITS {
     virtual Int_t GetCoolingFluid() const{ 
         // Get flag for cooling fluid
         return fFluid;}
+    //
+    // Print class in ascii form to stream
+    virtual void PrintAscii(ostream *os)const;
+    // Read in class in ascii form from stream
+    virtual void ReadAscii(istream *is);
 
  private:
-    AliITSvPPRasymmFMD(const AliITSvPPRasymmFMD &source); // copy constructor
-    AliITSvPPRasymmFMD& operator=(const AliITSvPPRasymmFMD &source); // assignment operator
+    // copy constructor. Will not copy class, just gives warning.
+    AliITSvPPRasymmFMD(const AliITSvPPRasymmFMD &source);
+    // assignment operator. Will not copy class, just gives warning.
+    AliITSvPPRasymmFMD& operator=(const AliITSvPPRasymmFMD &source);
     void InitAliITSgeom();
+    Bool_t IsDensityServicesByThickness()const {return fByThick;}
+    // returns Euclid file name with where Euclid geometry is kept.
+    const TString & GetEuclidFile()const{return fEuclidGeomDet;}
+    // Return Mother volume ID
+    Int_t GetMotherID()const {return fIDMother;}
+    // Return AliITSInitGeometry object
+    const AliITSInitGeometry & GetGeomInit()const{return fIgm;}
 
     // TString fEuclidGeomtery,fEuclidMaterial defined in AliModule.
-    Bool_t fGeomDetOut;       // Flag to write .det file out
-    Bool_t fGeomDetIn;        // Flag to read .det file or directly from Geat.
-    Bool_t fByThick;          // Flag to use services materials by thickness
-                              // ture, or mass false.
-    Int_t  fMajorVersion;     // Major version number == IsVersion
-    Int_t  fMinorVersion;     // Minor version number
-    char   fEuclidGeomDet[60];// file where detector transormation are define.
-    char   fRead[60];         //! file name to read .det file
-    char   fWrite[60];        //! file name to write .det file
-    Float_t  fDet1;          // thickness of detector in SPD layer 1
-    Float_t  fDet2;          // thickness of detector in SPD layer 2
-    Float_t  fChip1;         // thickness of chip in SPD layer 1   
-    Float_t  fChip2;         // thickness of chip in SPD layer 2   
-    Int_t    fRails;          // flag to switch rails on (=1) and off (=0)
-    Int_t    fFluid;          // flag to switch between water (=1) and freon (=0)
-    Int_t fIDMother;          //! ITS Mother Volume id.
+    Bool_t  fGeomDetOut;    // Flag to write .det file out
+    Bool_t  fGeomDetIn;     // Flag to read .det file or directly from Geat.
+    Bool_t  fByThick;       // Flag to use services materials by thickness
+                            // ture, or mass false.
+    Int_t   fMajorVersion;  // Major version number == IsVersion
+    Int_t   fMinorVersion;  // Minor version number
+    TString fEuclidGeomDet; // file where detector transormation are define.
+    TString fRead;          //! file name to read .det file
+    TString fWrite;         //! file name to write .det file
+    Float_t fDet1;         // thickness of detector in SPD layer 1
+    Float_t fDet2;          // thickness of detector in SPD layer 2
+    Float_t fChip1;         // thickness of chip in SPD layer 1   
+    Float_t fChip2;         // thickness of chip in SPD layer 2   
+    Int_t   fRails;         // flag to switch rails on (=1) and off (=0)
+    Int_t   fFluid;         // flag to switch between water (=1) and freon (=0)
+    Int_t   fIDMother;      //! ITS Mother Volume id.
+    AliITSInitGeometry fIgm;//! Get access to decoding and AliITSgeom init functins
 
-    ClassDef(AliITSvPPRasymmFMD,3)  //Hits manager for set:ITS version 8 
-                                 // PPR detailed Geometry asymmetric
+    ClassDef(AliITSvPPRasymmFMD,4) //Hits manager for set:ITS version 10
+                                   // PPR detailed Geometry asymmetric
 };
+// Input and output function for standard C++ input/output.
+ostream &operator<<(ostream &os,const AliITSvPPRasymmFMD &s);
+istream &operator>>(istream &is,AliITSvPPRasymmFMD &s);
+
 #endif
index b67f38f371a065e5179557997a2d0046eb40cff8..8befa6e4c7e542388acbf3de1824fb525b458dbc 100644 (file)
@@ -39,7 +39,7 @@
 #include <TVector.h>
 #include <TVirtualMC.h>
 #include <TGeometry.h>
-
+#include <TGeoManager.h>
 
 #include "AliMagF.h"
 #include "AliConst.h"
@@ -52,10 +52,12 @@ ClassImp(AliITSvPPRcoarseasymm)
  
 //_____________________________________________________________________________
 AliITSvPPRcoarseasymm::AliITSvPPRcoarseasymm():
-fMajorVersion(9),
+AliITS(),
+fMajorVersion(IsVersion()),
 fMinorVersion(0),
 fRails(0),
-fSuppMat(0) {
+fSuppMat(0),
+fIgm(kvPPRcourseasymm) {
 ////////////////////////////////////////////////////////////////////////
 //    Standard default constructor for the ITS version 6.
 ////////////////////////////////////////////////////////////////////////
@@ -65,11 +67,13 @@ fSuppMat(0) {
     fIdSens    = 0;
 }
 //_____________________________________________________________________________
-AliITSvPPRcoarseasymm::AliITSvPPRcoarseasymm(const char *name, const char *title) : AliITS(name, title),
-fMajorVersion(9),
+AliITSvPPRcoarseasymm::AliITSvPPRcoarseasymm(const char *name, const char *title) : 
+AliITS(name, title),
+fMajorVersion(IsVersion()),
 fMinorVersion(0),
 fRails(0),
-fSuppMat(0) {
+fSuppMat(0),
+fIgm(kvPPRcourseasymm) {
 ////////////////////////////////////////////////////////////////////////
 //    Standard constructor for the ITS version 6.
 ////////////////////////////////////////////////////////////////////////
@@ -140,137 +144,161 @@ void AliITSvPPRcoarseasymm::BuildGeometry(){
 }
 //_____________________________________________________________________________
 void AliITSvPPRcoarseasymm::CreateGeometry(){
-////////////////////////////////////////////////////////////////////////
-//    This routine defines and Creates the geometry for version 6 of the ITS.
-////////////////////////////////////////////////////////////////////////
-  
-  //INNER RADII OF THE SILICON LAYERS 
-  Float_t rl[6]    = { 3.8095,7.,15.,24.,38.5,43.5765 };   
-  //THICKNESSES OF LAYERS (in % radiation length)
-  Float_t drl[6]   = { 1.03,1.03,0.94,0.95,0.91,0.87 };   
-  //HALF LENGTHS OF LAYERS  
-  Float_t dzl[6]   = { 14.35,14.35,25.1,32.1,49.405,55.27 };
-  //LENGTHS OF END-LADDER BOXES (ALL INCLUDED)
-  Float_t dzb[6]   = { 12.4,12.4,13.5,15.,7.5,7.5 };   
-  //THICKNESSES OF END-LADDER BOXES (ALL INCLUDED)
-  Float_t drb[6]   = { rl[1]-rl[0],0.2,5.,5.,4.,4. };        
+    ////////////////////////////////////////////////////////////////////////
+    // This routine defines and Creates the geometry for version 6 of the ITS.
+    ////////////////////////////////////////////////////////////////////////
+  
+    //INNER RADII OF THE SILICON LAYERS 
+    Float_t rl[6]    = { 3.8095,7.,15.,24.,38.5,43.5765 };   
+    //THICKNESSES OF LAYERS (in % radiation length)
+    Float_t drl[6]   = { 1.03,1.03,0.94,0.95,0.91,0.87 };   
+    //HALF LENGTHS OF LAYERS  
+    Float_t dzl[6]   = { 14.35,14.35,25.1,32.1,49.405,55.27 };
+    //LENGTHS OF END-LADDER BOXES (ALL INCLUDED)
+    Float_t dzb[6]   = { 12.4,12.4,13.5,15.,7.5,7.5 };   
+    //THICKNESSES OF END-LADDER BOXES (ALL INCLUDED)
+    Float_t drb[6]   = { rl[1]-rl[0],0.2,5.,5.,4.,4. };        
 
  
-  Float_t dits[3], rlim, zmax;
-  Float_t zpos;
-  Float_t pcits[100], ztpc;
-  Int_t idrotm[1999], i;
-  Float_t dgh[100];
-  
-  Int_t rails = 1;       // flag for rails (1 --> rails in; 0 --> rails out)
-  Int_t suppmat = 0;     // flag to change the material of the services
-                         // supports (=0 copper, =1 aluminum, =2 carbon)  
-  rails = GetRails();
-  
-  if(rails != 0 && rails != 1) {
-     cout << "ITS - WARNING: the switch for rails is not set neither to 0 (rails out) nor to 1 (rails in)." 
-     " The default value of 1 (rails in) will be used." << endl;
-  }  
-  
-  if (rails == 0 ) {
-     cout << "ITS: Rails are out." << endl; 
-  } else {
-     cout << "ITS: Rails are in." << endl;
-  }      
-  
-  suppmat = GetSupportMaterial();   
-  
-  if (suppmat != 0 && suppmat != 1 && suppmat != 2) {
-     cout << "ITS - WARNING: the flag for the material of services supports is not set neither to 0 (copper) nor to 1 (aluminum) nor to 2 (carbon)." 
-     " The default value of 0 (copper) will be used." << endl;
-  }  
-  
-  if (suppmat == 0) {
-     cout << "ITS: The material of the services supports is copper." << endl; 
-  } else if (suppmat == 1){
-     cout << "ITS: The material of the services supports is aluminum." << endl;
-  } else {
-     cout << "ITS: The material of the services supports is carbon." << endl;
-  }      
+    Float_t dits[3], rlim, zmax;
+    Float_t zpos;
+    Float_t pcits[100], ztpc;
+    Int_t idrotm[1999], i;
+    Float_t dgh[100];
+  
+    Int_t rails = 1;       // flag for rails (1 --> rails in; 0 --> rails out)
+    Int_t suppmat = 0;     // flag to change the material of the services
+                           // supports (=0 copper, =1 aluminum, =2 carbon)
+    // These constant character strings are set by cvs during commit
+    // do not change them unless you know what you are doing!
+    const Char_t *cvsDate="$Date$";
+    const Char_t *cvsRevision="$Revision$";
+    rails = GetRails();
+  
+    if(rails != 0 && rails != 1) {
+        cout << "ITS - WARNING: the switch for rails is not set "
+            "neither to 0 (rails out) nor to 1 (rails in)." 
+            " The default value of 1 (rails in) will be used." << endl;
+    }  // end if
+  
+    if (rails == 0 ) {
+        cout << "ITS: Rails are out." << endl; 
+    } else {
+        cout << "ITS: Rails are in." << endl;
+    } // end if 
+    suppmat = GetSupportMaterial();   
+  
+    if (suppmat != 0 && suppmat != 1 && suppmat != 2) {
+        cout << "ITS - WARNING: the flag for the material of "
+            "services supports is not set neither to 0 (copper) "
+            "nor to 1 (aluminum) nor to 2 (carbon)." 
+            " The default value of 0 (copper) will be used." << endl;
+    }   // end if
+  
+    if (suppmat == 0) {
+        cout << "ITS: The material of the services supports is copper." 
+             << endl; 
+    } else if (suppmat == 1){
+        cout << "ITS: The material of the services supports is aluminum." 
+             << endl;
+    } else {
+        cout << "ITS: The material of the services supports is carbon." 
+             << endl;
+    } // end if
       
 
-  Int_t *idtmed = fIdtmed->GetArray()-199;
+    Int_t *idtmed = fIdtmed->GetArray()-199;
   
-  //     CONVERT INTO CM (RL(SI)=9.36 CM) 
-  for (i = 0; i < 6; ++i) {
-    drl[i] = drl[i] / 100. * 9.36;
-  }
+    //     CONVERT INTO CM (RL(SI)=9.36 CM) 
+    for (i = 0; i < 6; ++i) {
+        drl[i] = drl[i] / 100. * 9.36;
+    } // end if
     
-  //     FIELD CAGE HALF LENGTH 
-  
-  rlim  = 50.;
-  zmax  = 74.;
-  ztpc = 284.;
-  
-  // --- Define ghost volume containing the whole ITS (including services) 
-  //     and fill it with air 
-  
-  dgh[0] = 0.;
-  dgh[1] = 360.;
-  dgh[2] = 16.;
-  dgh[3] = -ztpc-5.-0.1;
-  dgh[4] = 46;   
-  dgh[5] = 85.;
-  dgh[6] = -ztpc;
-  dgh[7] = 46;   
-  dgh[8] = 85.;
-  dgh[9] = -ztpc;
-  dgh[10] = 46;  
-  dgh[11] = rlim+6;
-  dgh[12] = -97.5;
-  dgh[13] = 46;  
-  dgh[14] = rlim+6;
-  dgh[15] = -zmax;
-  dgh[16] = 46;  
-  dgh[17] = rlim+6;
-  dgh[18] = -48;   
-  dgh[19] = 6;
-  dgh[20] = rlim+6;
-  dgh[21] = -28.6;   
-  dgh[22] = 6;
-  dgh[23] = rlim+6;    
-  dgh[24] = -27.6;  
-  dgh[25] = 3.295;
-  dgh[26] = rlim+6; 
-  dgh[27] = 27.6;   
-  dgh[28] = 3.295;
-  dgh[29] = rlim+6;
-  dgh[30] = 28.6;   
-  dgh[31] = 6;
-  dgh[32] = rlim+6;
-  dgh[33] = 48;   
-  dgh[34] = 6;
-  dgh[35] = rlim+6;  
-  dgh[36] = zmax;
-  dgh[37] = 46;
-  dgh[38] = rlim+6;
-  dgh[39] = 97.5;
-  dgh[40] = 46;  
-  dgh[41] = rlim+6;
-  dgh[42] = ztpc;
-  dgh[43] = 62;     
-  dgh[44] = 62+4.;  
-  dgh[45] = ztpc;
-  dgh[46] = 62;     
-  dgh[47] = 85.;
-  dgh[48] = ztpc+4.+0.1;
-  dgh[49] = 62.4;
-  dgh[50] = 85.;
-  gMC->Gsvolu("ITSV", "PCON", idtmed[275], dgh, 51);
-  
-  // --- Place the ghost volume in its mother volume (ALIC) and make it 
-  //     invisible 
-  
-  gMC->Gspos("ITSV", 1, "ALIC", 0., 0., 0., 0, "ONLY");
-  //gMC->Gsatt("ITSV", "SEEN", 0); 
+    //     FIELD CAGE HALF LENGTH 
+  
+    rlim  = 50.;
+    zmax  = 74.;
+    ztpc = 284.;
+  
+    // --- Define ghost volume containing the whole ITS (including services) 
+    //     and fill it with air 
+    /*
+    dgh[0] = 0.;
+    dgh[1] = 360.;
+    dgh[2] = 16.;
+    dgh[3] = -ztpc-5.-0.1;
+    dgh[4] = 46;   
+    dgh[5] = 85.;
+    dgh[6] = -ztpc;
+    dgh[7] = 46;   
+    dgh[8] = 85.;
+    dgh[9] = -ztpc;
+    dgh[10] = 46;  
+    dgh[11] = rlim+6;
+    dgh[12] = -97.5;
+    dgh[13] = 46;  
+    dgh[14] = rlim+6;
+    dgh[15] = -zmax;
+    dgh[16] = 46;  
+    dgh[17] = rlim+6;
+    dgh[18] = -48;   
+    dgh[19] = 6;
+    dgh[20] = rlim+6;
+    dgh[21] = -28.6;   
+    dgh[22] = 6;
+    dgh[23] = rlim+6;    
+    dgh[24] = -27.6;  
+    dgh[25] = 3.295;
+    dgh[26] = rlim+6; 
+    dgh[27] = 27.6;   
+    dgh[28] = 3.295;
+    dgh[29] = rlim+6;
+    dgh[30] = 28.6;   
+    dgh[31] = 6;
+    dgh[32] = rlim+6;
+    dgh[33] = 48;   
+    dgh[34] = 6;
+    dgh[35] = rlim+6;  
+    dgh[36] = zmax;
+    dgh[37] = 46;
+    dgh[38] = rlim+6;
+    dgh[39] = 97.5;
+    dgh[40] = 46;  
+    dgh[41] = rlim+6;
+    dgh[42] = ztpc;
+    dgh[43] = 62;     
+    dgh[44] = 62+4.;  
+    dgh[45] = ztpc;
+    dgh[46] = 62;     
+    dgh[47] = 85.;
+    dgh[48] = ztpc+4.+0.1;
+    dgh[49] = 62.4;
+    dgh[50] = 85.;
+    gMC->Gsvolu("ITSV", "PCON", idtmed[275], dgh, 51);
+  
+    // --- Place the ghost volume in its mother volume (ALIC) and make it 
+    //     invisible 
+  
+    gMC->Gspos("ITSV", 1, "ALIC", 0., 0., 0., 0, "ONLY");
+    //gMC->Gsatt("ITSV", "SEEN", 0);
+    */
+    TGeoVolumeAssembly *itsV = gGeoManager->MakeVolumeAssembly("ITSV");
+    const Int_t length=100;
+    Char_t vstrng[length];
+    if(fIgm.WriteVersionString(vstrng,length,(AliITSVersion_t)IsVersion(),
+                               fMinorVersion,cvsDate,cvsRevision))
+        itsV->SetTitle(vstrng);
 
+    TGeoVolume *alic = gGeoManager->GetVolume("ALIC");
+    if(alic==0) {
+        Error("CreateGeometry","alic=0");
+        return;
+    } // end if
+    // See idrotm[199] for angle definitions.
+    //alic->AddNode(itsV,1,new TGeoRotation("", 90.,180., 90.,90., 180.,0.));
+    alic->AddNode(itsV,1,0);
 
-  // --- Define ghost volume containing the six layers and fill it with air 
+    // --- Define ghost volume containing the six layers and fill it with air 
   
   dgh[0] = 0.;
   dgh[1] = 360.;
index 6bff0fc72f15092619d684b900abc4cfbf4e6b43..f6b17eec0c7aebbb99d16484cfb9952dfc715223 100644 (file)
@@ -8,7 +8,7 @@
 /////////////////////////////////////////////////////////
 //  Manager and hits classes for set: ITS version 6    //
 /////////////////////////////////////////////////////////
+#include "AliITSInitGeometry.h" 
 #include "AliITS.h"
  
 class AliITSvPPRcoarseasymm : public AliITS {
@@ -22,7 +22,7 @@ class AliITSvPPRcoarseasymm : public AliITS {
     virtual void   CreateMaterials();
     virtual void   Init(); 
     virtual Int_t  IsVersion() const {// returns the ITS version number 
-       return 6;}
+       return (Int_t)kvPPRcourseasymm;}
     virtual void   DrawModule() const;
     virtual void   StepManager();
     virtual void   SetRails(Int_t v=1){ 
@@ -52,8 +52,9 @@ class AliITSvPPRcoarseasymm : public AliITS {
     Int_t  fRails;            // flag to switch rails on (=1) and off (=0)
     Int_t  fSuppMat;          // flag to change the material of the services
                               // supports (=0 copper, =1 aluminum, =2 carbon)
+    AliITSInitGeometry fIgm;  //! Geometry initlization object
                                  
-    ClassDef(AliITSvPPRcoarseasymm,1)  //Hits manager for set:ITS version 6 
+    ClassDef(AliITSvPPRcoarseasymm,2)  //Hits manager for set:ITS version 6 
                                        // PPR coarse Geometry asymmetric
 };
  
index 550f00e687abbb1e64790373f051055700ae6605..20c01556295587a5457aeb6b5c553dffe6dc341b 100644 (file)
@@ -23,6 +23,7 @@
 /////////////////////////////////////////////////////////////////
 
 #include <TGeometry.h>
+#include <TGeoManager.h>
 #include <TNode.h>
 #include <TBRIK.h>
 #include <TLorentzVector.h>
@@ -34,8 +35,6 @@
 #include "AliMagF.h"
 #include "AliTrackReference.h"
 #include "AliITShit.h"
-#include "AliITS.h"
-#include "AliITSvSDD03.h"
 #include "AliITSgeom.h"
 #include "AliITSgeomSDD.h"
 #include "AliITSgeomSSD.h"
@@ -50,6 +49,7 @@
 #include "AliITSsimulationSDD.h"
 #include "AliITSsimulationSSD.h"
 
+#include "AliITSvSDD03.h"
 
 ClassImp(AliITSvSDD03)
 
@@ -58,17 +58,16 @@ AliITSvSDD03::AliITSvSDD03() :
 AliITS(),
 fGeomDetOut(kFALSE),
 fGeomDetIn(kFALSE),
-fMajorVersion(1),
+fMajorVersion(IsVersion()),
 fMinorVersion(2),
 fEuclidGeomDet(),
 fRead(),
 fWrite(),
-fDet1(300.0),
-fDet2(300.0),
-fChip1(300.0),
-fChip2(300.0),
 fIDMother(0),
-fYear(2003){
+fYear(2003),
+fTarg(kNoTarg),
+fTargThick(0.0),
+fIgm(kvSDD03){
     ////////////////////////////////////////////////////////////////////////
     // Standard default constructor for the ITS SDD test beam 2002 version 1.
     // Inputs:
@@ -87,25 +86,22 @@ fYear(2003){
     for(i=0;i<60;i++) fRead[i] = '\0';
     for(i=0;i<60;i++) fWrite[i] = '\0';
     for(i=0;i<60;i++) fEuclidGeomDet[i] = '\0';
-    fTarg=kNoTarg;
-    fTargThick=0;
 }
 //______________________________________________________________________
 AliITSvSDD03::AliITSvSDD03(const char *title,Int_t year):
 AliITS("ITS", title),
 fGeomDetOut(kFALSE),
 fGeomDetIn(kFALSE),
-fMajorVersion(1),
+fMajorVersion(IsVersion()),
 fMinorVersion(2),
 fEuclidGeomDet(),
 fRead(),
 fWrite(),
-fDet1(300.0),
-fDet2(300.0),
-fChip1(300.0),
-fChip2(300.0),
 fIDMother(0),
-fYear(2003){
+fYear(year),
+fTarg(kNoTarg),
+fTargThick(0.0),
+fIgm(kvSDD03){
     ////////////////////////////////////////////////////////////////////////
     //    Standard constructor for the ITS SDD testbeam 2002 version 1.
     // Inputs:
@@ -125,13 +121,6 @@ fYear(2003){
     fIdSens    = new Int_t[fIdN];
     for(i=0;i<fIdN;i++) fIdSens[i] = 0;
     fEuclidOut    = kFALSE; // Don't write Euclide file
-    fYear         = year;
-    fTarg=kNoTarg;
-    fTargThick=0;    
-    SetThicknessDet1();
-    SetThicknessDet2();
-    SetThicknessChip1();
-    SetThicknessChip2();                        
 
     fEuclidGeometry="$ALICE_ROOT/ITS/ITSgeometry_vSDD032.euc";
     strncpy(fEuclidGeomDet,"$ALICE_ROOT/ITS/ITSgeometry_vSDD032.det",60);
@@ -271,6 +260,7 @@ void AliITSvSDD03::BuildGeometry(){
     nALIC->cd();
     sITSV->Draw();
 }
+/*
 //______________________________________________________________________
 Int_t AliITSvSDD03::DecodeDetector(Int_t id,Int_t cpy,Int_t &lay,
                                    Int_t &det,Int_t &lad) const{
@@ -304,13 +294,14 @@ Int_t AliITSvSDD03::DecodeDetector(Int_t id,Int_t cpy,Int_t &lay,
     }// end if
     return mod;
 }
+*/
 //______________________________________________________________________
 void AliITSvSDD03::CreateGeometry(){
     ////////////////////////////////////////////////////////////////////////
     //  This routine defines and Creates the geometry for version 1 of the ITS.
     //    ALIC    ALICE Mother Volume
     //     |- ITSV     ITS Mother Volume
-    //         |- IDET       Detector under Test (boxcontaining SDD)
+    //         |- IDET *2    Detector under Test (boxcontaining SDD)
     //         |   |-IDAI        Air inside box
     //         |       |- ITS0       SDD Si Chip
     //         |          |- ITST      SDD Sensitivve Volume
@@ -319,6 +310,12 @@ void AliITSvSDD03::CreateGeometry(){
     //         |       |- IMB0       SDD Si Chip
     //         |           |- IMBS     SDD Sensitive volume
     //         |-ISNT*4    Sintilator triggers
+    //
+    //      ITEL ITEL ITEL ITEL IDET IDET ITEL ITEL ITEL ITEL ITEL ITEL
+    // Z->  -584 -574 -504 -494  000 +052 +601 +610 +684 +694 +877 +887
+    //        |    |    |    |    |    |    |    |    |    |    |    |
+    // cpn1   1    2    3    4    1    2    5    6    7    8    9   10
+    //
     // Inputs:
     //    none.
     // Outputs:
@@ -334,18 +331,36 @@ void AliITSvSDD03::CreateGeometry(){
     //Float_t dchipMiniBus=750.0E-4,dchiptest=300.0E-4;
     //Float_t yposition= 0.0;
     const Float_t kmm=0.1,kcm=1.0,kmicm=kmm/1000.;
+    // These constant character strings are set by cvs during commit
+    // do not change them unless you know what you are doing!
+    const Char_t *cvsDate="$Date$";
+    const Char_t *cvsRevision="$Revision$";
     // Define Rotation-reflextion Matrixes needed
     // 0 is the unit matrix
     AliMatrix(idrotm[0], 90.0,0.0, 0.0,0.0, 90.0,270.0); // SDD and SSD X
     AliMatrix(idrotm[1], 90.0,90.0, 0.0,180.0, 90.0,270.0); // SSD Y
     AliMatrix(idrotm[2],90.0,90.0,90.0,180.0,0.0,0.0);  //Rotate about Z 90 degree
-
+    /*
     data[0] = 150.0*kmm;
     data[1] = 150.0*kmm;
     data[2] = 1100.0*kmm;
     gMC->Gsvolu("ITSV","BOX ",idtmed[0],data,3);
     gMC->Gspos("ITSV",1,"ALIC",0.0,0.0,0.0,0,"ONLY");
-
+    */
+    TGeoVolumeAssembly *itsV = gGeoManager->MakeVolumeAssembly("ITSV");
+    const Int_t length=100;
+    Char_t vstrng[length];
+    if(fIgm.WriteVersionString(vstrng,length,(AliITSVersion_t)IsVersion(),
+                               fMinorVersion,cvsDate,cvsRevision))
+        itsV->SetTitle(vstrng);
+    else Error("CreateGeometry","Error writing/setting version string");
+    //printf("Title set to %s\n",vstrng);
+    TGeoVolume *alic = gGeoManager->GetVolume("ALIC");
+    if(alic==0) {
+        Error("CreateGeometry","alic=0");
+        return;
+    } // end if
+    alic->AddNode(itsV,1,0);
 
     // Crossed sintilator triggers (2 in front 2 in back)
     data[0] = 10.0*kcm;
@@ -664,7 +679,7 @@ void AliITSvSDD03::CreateMaterials(){
    AliMedium(96,"SI$",2,0,ifield,fieldm,tmaxfdSi,stemaxSi,deemaxSi,
              epsilSi,stminSi);
 
-}           
+}/*
 //______________________________________________________________________
 void AliITSvSDD03::InitAliITSgeom(){
     //     Based on the geometry tree defined in Geant 3.21, this
@@ -685,7 +700,7 @@ void AliITSvSDD03::InitAliITSgeom(){
         "/ALIC_1/ITSV_1/IDET_%d/IDAI_1/ITS0_1/ITST_1"};
     const Int_t kitsGeomTreeCopys[kltypess]={10,2};
     const Int_t knp=384;
-    const Float_t kpitch=50.E-4;/*cm*/
+    const Float_t kpitch=50.E-4;//cm
     Float_t box[3]={0.5*kpitch*(Float_t)knp,150.E-4,1.0},p[knp+1],n[knp+1];
     Int_t nlad[knlayers]={knlayers*1};
     Int_t ndet[knlayers]={knlayers*1};
@@ -735,7 +750,7 @@ void AliITSvSDD03::InitAliITSgeom(){
         } // end switch
     } // end for i,cp0
     return;
-}
+}*/
 //______________________________________________________________________
 void AliITSvSDD03::Init(){
     ////////////////////////////////////////////////////////////////////////
@@ -751,18 +766,17 @@ void AliITSvSDD03::Init(){
 
     Info("Init","**********AliITSvSDD03 %d _Init *************",fMinorVersion);
 
-    if(fRead[0]=='\0') strncpy(fRead,fEuclidGeomDet,60);
-    if(fWrite[0]=='\0') strncpy(fWrite,fEuclidGeomDet,60);
-    if(GetITSgeom()!=0) SetITSgeom(0x0);
-    AliITSgeom* geom = new AliITSgeom();
-    SetITSgeom(geom);
-    if(fGeomDetIn) GetITSgeom()->ReadNewFile(fRead);
-    if(!fGeomDetIn) this->InitAliITSgeom();
-    if(fGeomDetOut) GetITSgeom()->WriteNewFile(fWrite);
+    AliDebug(1,Form("Init: Major version %d Minor version %d",fMajorVersion,
+                 fMinorVersion));
+    //
+    UpdateInternalGeometry();
     AliITS::Init();
+    if(fGeomDetOut) GetITSgeom()->WriteNewFile(fWrite);
+
+    //
     fIDMother = gMC->VolId("ITSV"); // ITS Mother Volume ID.
 
-}
+}/*
 //______________________________________________________________________
 void AliITSvSDD03::SetDefaults(){
     // sets the default segmentation, response, digit and raw cluster classes
@@ -889,7 +903,7 @@ void AliITSvSDD03::SetDefaultSimulation(){
       sim->Init();
     } // end if
   } // end if iDetType
-}
+  }*/
 //______________________________________________________________________
 void AliITSvSDD03::DrawModule() const{
     ////////////////////////////////////////////////////////////////////////
@@ -942,71 +956,60 @@ void AliITSvSDD03::StepManager(){
     // Return:
     //    none.
     ////////////////////////////////////////////////////////////////////////
-    Int_t  copy, id;
-    static TLorentzVector position0;
-    static Int_t stat0=0;
-    if((id=gMC->CurrentVolID(copy) == fIDMother)&&
-       (gMC->IsTrackEntering()||gMC->IsTrackExiting())){
-        copy = fTrackReferences->GetEntriesFast();
-        TClonesArray &lTR = *fTrackReferences;
-        // Fill TrackReference structure with this new TrackReference.
-        new(lTR[copy]) AliTrackReference(gAlice->GetMCApp()->
-                                         GetCurrentTrackNumber());
-    } // if Outer ITS mother Volume
-    //if(!(this->IsActive())) return;
+    if(!(this->IsActive())) return;
     if(!(gMC->TrackCharge())) return;
-    Int_t   vol[5],copy3;
+
+    Int_t  cpy0,cpy1,ncpys=0,status,id,mod;
     TLorentzVector position, momentum;
-    TClonesArray &lhits = *fHits;
+    static AliITShit hit;// Saves on calls to construtors
+    //TClonesArray &lhits = *(GetDetTypeSim()->GetHits());
+    TClonesArray &lhits = *(Hits());
+    //
+    // Track status
+    // Track status
+    status = 0;
+    if(gMC->IsTrackInside())      status +=  1;
+    if(gMC->IsTrackEntering())    status +=  2;
+    if(gMC->IsTrackExiting())     status +=  4;
+    if(gMC->IsTrackOut())         status +=  8;
+    if(gMC->IsTrackDisappeared()) status += 16;
+    if(gMC->IsTrackStop())        status += 32;
+    if(gMC->IsTrackAlive())       status += 64;
     //
     // Fill hit structure.
     gMC->TrackPosition(position);
     gMC->TrackMomentum(momentum);
-    id   = gMC->CurrentVolID(copy);
-    if(id==fIdSens[0] || id==fIdSens[1]){ // Volumes "ITST" or "IMBS"
-        copy = gMC->CurrentVolOffID(3,copy3);
-        copy = DecodeDetector(id,copy3,vol[0],vol[1],vol[2]);
-       //    cout << "0: mod,lay,lad,det="<<copy<<","<<vol[0]<<","<<vol[1]
-        //     <<","<<vol[2]<<" name="<<gMC->CurrentVolName()
-       //     <<","<<fIdSens[0]<<","<<fIdSens[1]<<","<<id<<" z="
-        //     <<position.Z()<<endl;
-    }else if(id==fIdSens[2]){ // "ISNT" Sintilator
-        //cout << "1: id,copy="<<id<<","<<copy
-        //     <<" name="<<gMC->CurrentVolName()<<" z="
-        //     <<position.Z()<<endl;
-        return; // Do nothing for now.
-    }else{
-        //cout << "2: id,copy="<<id<<","<<copy
-        //  &