Geometry update, Removal of compiler warnings
authorcblume <cblume@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 18 Sep 2003 09:06:12 +0000 (09:06 +0000)
committercblume <cblume@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 18 Sep 2003 09:06:12 +0000 (09:06 +0000)
34 files changed:
TRD/AliTRD.cxx
TRD/AliTRDclusterizer.cxx
TRD/AliTRDclusterizerV1.cxx
TRD/AliTRDdataArray.cxx
TRD/AliTRDdataArrayF.cxx
TRD/AliTRDdataArrayI.cxx
TRD/AliTRDdigitizer.cxx
TRD/AliTRDdigitsManager.cxx
TRD/AliTRDgeometry.cxx
TRD/AliTRDgeometry.h
TRD/AliTRDgeometryDetail.cxx
TRD/AliTRDgeometryFull.cxx
TRD/AliTRDgeometryFull.h
TRD/AliTRDgeometryHole.cxx
TRD/AliTRDmatrix.cxx
TRD/AliTRDparameter.cxx
TRD/AliTRDpid.cxx
TRD/AliTRDpidLQ.cxx
TRD/AliTRDpoints.cxx
TRD/AliTRDrecPoint.cxx
TRD/AliTRDrecPoint.h
TRD/AliTRDsegmentArray.cxx
TRD/AliTRDsegmentArrayBase.cxx
TRD/AliTRDsim.cxx
TRD/AliTRDsimple.cxx
TRD/AliTRDsimpleGen.cxx
TRD/AliTRDsimpleMC.cxx
TRD/AliTRDsimpleMC.h
TRD/AliTRDtrack.cxx
TRD/AliTRDtrackHits.cxx
TRD/AliTRDtracker.cxx
TRD/AliTRDtracker.h
TRD/AliTRDv1.cxx
TRD/AliTRDv2.cxx

index b9d0ec8cce874ecb1d111a6c88d5a6cb8dd89dd3..3a8e4e57ed40ee8b9c903add7a8c8d33e61a937b 100644 (file)
@@ -144,7 +144,7 @@ AliTRD::AliTRD(const char *name, const char *title)
 }
 
 //_____________________________________________________________________________
-AliTRD::AliTRD(const AliTRD &trd)
+AliTRD::AliTRD(const AliTRD &trd):AliDetector(trd)
 {
   //
   // Copy constructor
@@ -700,6 +700,9 @@ void AliTRD::CreateMaterials()
   // Al of cooling pipes
   AliMedium(24, "Cooling" ,   1, 0, isxfld, sxmgmx
                 , tmaxfd, stemax, deemax, epsil, stmin);
+  // Cu in services
+  AliMedium(25, "Serv-Cu" ,   5, 0, isxfld, sxmgmx
+                , tmaxfd, stemax, deemax, epsil, stmin);
 
   // Save the density values for the TRD absorbtion
   fFoilDensity = dmy;
@@ -818,7 +821,7 @@ void AliTRD::Init()
 }
 
 //_____________________________________________________________________________
-void AliTRD::LoadPoints(Int_t track)
+void AliTRD::LoadPoints(Int_t )
 {
   //
   // Store x, y, z of all hits in memory.
@@ -1218,7 +1221,7 @@ AliHit* AliTRD::NextHit2()
 }
 
 //_____________________________________________________________________________
-void AliTRD::MakeBranch2(Option_t *option, const char *file)
+void AliTRD::MakeBranch2(Option_t *option, const char)
 {
   //
   // Create a new branch in the current Root tree.
index 58fcab22928da107e9319d728d21da2e87d009cf..a34efa0ca4aa7606c3bc32707eae0c51dd816ec9 100644 (file)
@@ -69,7 +69,7 @@ AliTRDclusterizer::AliTRDclusterizer(const Text_t* name, const Text_t* title)
 }
 
 //_____________________________________________________________________________
-AliTRDclusterizer::AliTRDclusterizer(const AliTRDclusterizer &c)
+AliTRDclusterizer::AliTRDclusterizer(const AliTRDclusterizer &c):TNamed(c)
 {
   //
   // AliTRDclusterizer copy constructor
index ed1ab35603491ef0eb0fd6f03d1cf99321130dc6..f72ac2fe5b6afc7a8e6b6f283152ebe5f155bf9c 100644 (file)
@@ -68,6 +68,7 @@ AliTRDclusterizerV1::AliTRDclusterizerV1(const Text_t* name, const Text_t* title
 
 //_____________________________________________________________________________
 AliTRDclusterizerV1::AliTRDclusterizerV1(const AliTRDclusterizerV1 &c)
+:AliTRDclusterizer(c)
 {
   //
   // AliTRDclusterizerV1 copy constructor
index 23a04b36e778a539b31f5088e96145432961f8d0..5e045f02ce5a910d5ce8bcddbdfad429db7ffe4d 100644 (file)
@@ -68,7 +68,7 @@ AliTRDdataArray::AliTRDdataArray(Int_t nrow, Int_t ncol, Int_t ntime)
 }
 
 //_____________________________________________________________________________
-AliTRDdataArray::AliTRDdataArray(const AliTRDdataArray &d)
+AliTRDdataArray::AliTRDdataArray(const AliTRDdataArray &d):AliTRDsegmentID(d)
 {
   //
   // AliTRDdataArray copy constructor
index 77ae5683d3ee87fdd5ddbbdf3f977eb73bf75d9d..4b9183f128441f8ce047a1881edc56a28adf9591 100644 (file)
@@ -55,7 +55,7 @@ AliTRDdataArrayF::AliTRDdataArrayF(Int_t nrow, Int_t ncol, Int_t ntime)
 }
 
 //_____________________________________________________________________________
-AliTRDdataArrayF::AliTRDdataArrayF(const AliTRDdataArrayF &a)
+AliTRDdataArrayF::AliTRDdataArrayF(const AliTRDdataArrayF &a):AliTRDdataArray(a)
 {
   //
   // AliTRDdataArrayF copy constructor
index 62d216cb17807ba7f5998aa269b1130e3abd0aad..8cfcd32eba7a441b33c438b3176a54b4f2402b75 100644 (file)
@@ -54,7 +54,7 @@ AliTRDdataArrayI::AliTRDdataArrayI(Int_t nrow, Int_t ncol, Int_t ntime)
 }
 
 //_____________________________________________________________________________
-AliTRDdataArrayI::AliTRDdataArrayI(const AliTRDdataArrayI &a)
+AliTRDdataArrayI::AliTRDdataArrayI(const AliTRDdataArrayI &a):AliTRDdataArray(a)
 {
   //
   // AliTRDdataArrayI copy constructor
index f9abbb7a0ea5d3758a8ef5cb702b9adaf3cbb046..0df0e23016dd2cc7856c71ae2cf34d609a62fab4 100644 (file)
@@ -196,7 +196,7 @@ AliTRDdigitizer::AliTRDdigitizer(AliRunDigitizer *manager)
 }
 
 //_____________________________________________________________________________
-AliTRDdigitizer::AliTRDdigitizer(const AliTRDdigitizer &d)
+AliTRDdigitizer::AliTRDdigitizer(const AliTRDdigitizer &d):AliDigitizer(d)
 {
   //
   // AliTRDdigitizer copy constructor
index 2279d744a319545f7d469dbac8506d9c555ca220..0cb030e0d284efaa640d6326c178dd3035de01fe 100644 (file)
@@ -66,6 +66,7 @@ AliTRDdigitsManager::AliTRDdigitsManager():TObject()
 
 //_____________________________________________________________________________
 AliTRDdigitsManager::AliTRDdigitsManager(const AliTRDdigitsManager &m)
+:TObject(m)
 {
   //
   // AliTRDdigitsManager copy constructor
index 22cfe450cee28b3f11f179d101e5f0e7591ff23b..6c22fb54bedac2d772946f476cc087c58ff6141b 100644 (file)
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
 
-/* $Id$ */
+/*
+$Log$
+Revision 1.22  2002/11/21 22:38:47  alibrary
+Removing AliMC and AliMCProcess
+
+Revision 1.21  2002/11/21 16:09:44  cblume
+Change fgkRpadW to 1.0 cm for new pad plane
+
+Revision 1.20  2002/10/31 17:45:35  cblume
+New chamber geometry
+
+Revision 1.19  2002/10/14 14:57:43  hristov
+Merging the VirtualMC branch to the main development branch (HEAD)
+
+Revision 1.15.6.2  2002/07/24 10:09:30  alibrary
+Updating VirtualMC
+
+Revision 1.15.6.1  2002/06/10 15:28:58  hristov
+Merged with v3-08-02
+
+Revision 1.17  2002/04/05 13:20:12  cblume
+Remove const for CreateGeometry
+
+Revision 1.16  2002/03/28 14:59:07  cblume
+Coding conventions
+
+Revision 1.18  2002/06/12 09:54:35  cblume
+Update of tracking code provided by Sergei
+
+Revision 1.17  2002/04/05 13:20:12  cblume
+Remove const for CreateGeometry
+
+Revision 1.16  2002/03/28 14:59:07  cblume
+Coding conventions
+
+Revision 1.15  2002/02/11 14:21:16  cblume
+Update of the geometry. Get rid of MANY
+
+Revision 1.14  2001/11/06 17:19:41  cblume
+Add detailed geometry and simple simulator
+
+Revision 1.13  2001/08/02 08:30:45  cblume
+Fix positions of cooling material
+
+Revision 1.12  2001/05/21 16:45:47  hristov
+Last minute changes (C.Blume)
+
+Revision 1.11  2001/05/11 07:56:12  hristov
+Consistent declarations needed on Alpha
+
+Revision 1.10  2001/05/07 08:08:05  cblume
+Update of TRD code
+
+Revision 1.9  2001/03/27 12:48:33  cblume
+Correct for volume overlaps
+
+Revision 1.8  2001/03/13 09:30:35  cblume
+Update of digitization. Moved digit branch definition to AliTRD
+
+Revision 1.7  2001/02/14 18:22:26  cblume
+Change in the geometry of the padplane
+
+Revision 1.6  2000/11/01 14:53:20  cblume
+Merge with TRD-develop
+
+Revision 1.1.4.7  2000/10/16 01:16:53  cblume
+Changed timebin 0 to be the one closest to the readout
+
+Revision 1.1.4.6  2000/10/15 23:35:57  cblume
+Include geometry constants as static member
+
+Revision 1.1.4.5  2000/10/06 16:49:46  cblume
+Made Getters const
+
+Revision 1.1.4.4  2000/10/04 16:34:58  cblume
+Replace include files by forward declarations
+
+Revision 1.1.4.3  2000/09/22 14:43:40  cblume
+Allow the pad/timebin-dimensions to be changed after initialization
+
+Revision 1.1.4.2  2000/09/18 13:37:01  cblume
+Minor coding corrections
+
+Revision 1.5  2000/10/02 21:28:19  fca
+Removal of useless dependecies via forward declarations
+
+Revision 1.4  2000/06/08 18:32:58  cblume
+Make code compliant to coding conventions
+
+Revision 1.3  2000/06/07 16:25:37  cblume
+Try to remove compiler warnings on Sun and HP
+
+Revision 1.2  2000/05/08 16:17:27  cblume
+Merge TRD-develop
+
+Revision 1.1.4.1  2000/05/08 14:45:55  cblume
+Bug fix in RotateBack(). Geometry update
+
+Revision 1.4  2000/06/08 18:32:58  cblume
+Make code compliant to coding conventions
+
+Revision 1.3  2000/06/07 16:25:37  cblume
+Try to remove compiler warnings on Sun and HP
+
+Revision 1.2  2000/05/08 16:17:27  cblume
+Merge TRD-develop
+
+Revision 1.1.4.1  2000/05/08 14:45:55  cblume
+Bug fix in RotateBack(). Geometry update
+
+Revision 1.1  2000/02/28 19:00:44  cblume
+Add new TRD classes
+
+*/
 
 ///////////////////////////////////////////////////////////////////////////////
 //                                                                           //
@@ -57,6 +170,10 @@ ClassImp(AliTRDgeometry)
   const Float_t AliTRDgeometry::fgkSlenTR2 = 313.5; 
   const Float_t AliTRDgeometry::fgkSlenTR3 = 159.5;  
 
+  // The super module side plates
+  const Float_t AliTRDgeometry::fgkSMpltT  = 0.2;
+  const Float_t AliTRDgeometry::fgkSMgapT  = 0.5;  
+
   // Height of different chamber parts
   // Radiator
   const Float_t AliTRDgeometry::fgkCraH    =   4.8; 
@@ -65,7 +182,7 @@ ClassImp(AliTRDgeometry)
   // Amplification region
   const Float_t AliTRDgeometry::fgkCamH    =   0.7;
   // Readout
-  const Float_t AliTRDgeometry::fgkCroH    =   2.0;
+  const Float_t AliTRDgeometry::fgkCroH    =   2.316;
   // Total height
   const Float_t AliTRDgeometry::fgkCH      = AliTRDgeometry::fgkCraH
                                            + AliTRDgeometry::fgkCdrH
@@ -73,7 +190,7 @@ ClassImp(AliTRDgeometry)
                                            + AliTRDgeometry::fgkCroH;  
 
   // Vertical spacing of the chambers
-  const Float_t AliTRDgeometry::fgkVspace  =   2.1;
+  const Float_t AliTRDgeometry::fgkVspace  =   1.784;
 
   // Horizontal spacing of the chambers
   const Float_t AliTRDgeometry::fgkHspace  =   2.0;
@@ -94,7 +211,8 @@ ClassImp(AliTRDgeometry)
   const Float_t AliTRDgeometry::fgkCroW    =   0.9;
 
   // Difference of outer chamber width and pad plane width
-  const Float_t AliTRDgeometry::fgkCpadW   =   1.0;
+  //const Float_t AliTRDgeometry::fgkCpadW   =   1.0;
+  const Float_t AliTRDgeometry::fgkCpadW   =   0.0;
   const Float_t AliTRDgeometry::fgkRpadW   =   1.0;
 
   //
@@ -179,14 +297,15 @@ void AliTRDgeometry::Init()
   Int_t isect;
 
   // The outer width of the chambers
-  fCwidth[0] =  95.6;
-  fCwidth[1] = 100.1;
-  fCwidth[2] = 104.5;
-  fCwidth[3] = 108.9;
-  fCwidth[4] = 113.4;
-  fCwidth[5] = 117.8;
+  fCwidth[0] =  94.8;
+  fCwidth[1] =  99.3;
+  fCwidth[2] = 103.7;
+  fCwidth[3] = 108.1;
+  fCwidth[4] = 112.6;
+  fCwidth[5] = 117.0;
 
   // The outer lengths of the chambers
+  // Includes the spacings between the chambers!
   Float_t length[kNplan][kNcham]   = { { 124.0, 124.0, 110.0, 124.0, 124.0 }
                                      , { 131.0, 131.0, 110.0, 131.0, 131.0 }
                                      , { 138.0, 138.0, 110.0, 138.0, 138.0 }
@@ -220,7 +339,7 @@ void AliTRDgeometry::Init()
 }
 
 //_____________________________________________________________________________
-void AliTRDgeometry::CreateGeometry(Int_t *idtmed)
+void AliTRDgeometry::CreateGeometry(Int_t)
 {
   //
   // Create TRD geometry
index f544bbbe13a8d65a8d90c3cd79877033300bc5db..7c72b9e92e1c3d663637d6ed19a9114f697d7798 100644 (file)
@@ -27,7 +27,7 @@ class AliTRDgeometry : public AliGeometry {
   virtual void     CreateGeometry(Int_t *idtmed);
   virtual Int_t    IsVersion() const = 0;
   virtual void     Init();
-  virtual Bool_t   Impact(const TParticle * particle) const { return kTRUE; };
+  virtual Bool_t   Impact(const TParticle) const { return kTRUE; };
   virtual Bool_t   Local2Global(Int_t d, Float_t *local, Float_t *global, AliTRDparameter *par) const;
   virtual Bool_t   Local2Global(Int_t p, Int_t c, Int_t s, Float_t *local, Float_t *global, AliTRDparameter *par) const;
   virtual Bool_t   Rotate(Int_t d, Float_t *pos, Float_t *rot) const;
@@ -75,8 +75,8 @@ class AliTRDgeometry : public AliGeometry {
           Float_t  GetChamberWidth(const Int_t p)                 const { return fCwidth[p];     };
           Float_t  GetChamberLength(const Int_t p, const Int_t c) const { return fClength[p][c]; }; 
 
-  virtual void     GetGlobal(const AliRecPoint *p, TVector3 &pos, TMatrix &mat) const { }; 
-  virtual void     GetGlobal(const AliRecPoint *p, TVector3 &pos) const { };
+  virtual void     GetGlobal(const AliRecPoint* , TVector3& , TMatrix& ) const { }; 
+  virtual void     GetGlobal(const AliRecPoint* , TVector3& ) const { };
  
   static  Double_t GetAlpha()  { return 2 * 3.14159265358979323846 / fgkNsect; }; 
 
@@ -100,6 +100,9 @@ class AliTRDgeometry : public AliGeometry {
   static const Float_t fgkSlenTR2;                          // Length of the TRD-volume in spaceframe (BTR2)
   static const Float_t fgkSlenTR3;                          // Length of the TRD-volume in spaceframe (BTR3)
 
+  static const Float_t fgkSMpltT;                           // Thickness of the super module side plates
+  static const Float_t fgkSMgapT;                           // Thickness of the gap between side plates and space frame
+
   static const Float_t fgkCraH;                             // Height of the radiator part of the chambers
   static const Float_t fgkCdrH;                             // Height of the drift region of the chambers
   static const Float_t fgkCamH;                             // Height of the amplification region of the chambers
@@ -156,7 +159,7 @@ class AliTRDgeometry : public AliGeometry {
   Float_t              fRotB21[kNsect];                     // Matrix elements for the backward rotation
   Float_t              fRotB22[kNsect];                     // Matrix elements for the backward rotation
 
-  ClassDef(AliTRDgeometry,5)                                // TRD geometry base class
+  ClassDef(AliTRDgeometry,6)                                // TRD geometry base class
 
 };
 
index 230b549c5961f223d3bbb6b20ecd64bfa7547b03..201ad7aa1b4da7830c27632ee2fb0f2ecb5b3fc7 100644 (file)
@@ -312,7 +312,6 @@ void AliTRDgeometryDetail::CreateReadout(Int_t *idtmed) const
   //
   // Create the volumina of the readout electronics
   //
-
   const Int_t   kNparBox    = 3;
 
   Float_t parBox[kNparBox];
index 7798f5f8c8c29229fbfc12e51ae2d889626ec6e1..ae69523abc3a1fae3cf6c5eb3319eb3132f95a3b 100644 (file)
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
 
-/* $Id$ */
+/*
+$Log$
+Revision 1.10  2002/11/21 22:38:47  alibrary
+Removing AliMC and AliMCProcess
+
+Revision 1.9  2002/10/31 17:45:35  cblume
+New chamber geometry
+
+Revision 1.8  2002/02/11 14:21:16  cblume
+Update of the geometry. Get rid of MANY
+
+Revision 1.7  2001/05/11 07:56:12  hristov
+Consistent declarations needed on Alpha
+
+Revision 1.6  2001/02/14 18:22:26  cblume
+Change in the geometry of the padplane
+
+Revision 1.5  2000/11/01 14:53:21  cblume
+Merge with TRD-develop
+
+Revision 1.1.4.6  2000/10/15 23:40:01  cblume
+Remove AliTRDconst
+
+Revision 1.1.4.5  2000/10/06 16:49:46  cblume
+Made Getters const
+
+Revision 1.1.4.4  2000/10/04 16:34:58  cblume
+Replace include files by forward declarations
+
+Revision 1.1.4.3  2000/09/22 14:43:41  cblume
+Allow the pad/timebin-dimensions to be changed after initialization
+
+Revision 1.4  2000/10/02 21:28:19  fca
+Removal of useless dependecies via forward declarations
+
+Revision 1.3  2000/06/08 18:32:58  cblume
+Make code compliant to coding conventions
+
+Revision 1.2  2000/05/08 16:17:27  cblume
+Merge TRD-develop
+
+Revision 1.1.4.2  2000/05/08 14:46:44  cblume
+Include options SetPHOShole() and SetRICHhole()
+
+Revision 1.1.4.1  2000/04/27 12:46:04  cblume
+Corrected bug in full geometry
+
+Revision 1.1  2000/02/28 19:01:15  cblume
+Add new TRD classes
+
+*/
 
 ///////////////////////////////////////////////////////////////////////////////
 //                                                                           //
 //                                                                           //
 ///////////////////////////////////////////////////////////////////////////////
 
-#include <TVirtualMC.h>
+#include "TVirtualMC.h"
+
 #include "AliTRDgeometryFull.h"
+#include "AliTRDparameter.h"
 
 ClassImp(AliTRDgeometryFull)
 
@@ -114,9 +166,6 @@ void AliTRDgeometryFull::CreateGeometry(Int_t *idtmed)
   //        UKxx    Amplification volume        (Xe/CO2)
   //        ULxx    Pad plane                   (Cu)
   //        UMxx    Support structure           (Rohacell)
-  //        UNxx    FEE + signal lines          (Cu)
-  //        UOxx    Cooling device              (Al)
-  //        UPxx    Cooling device              (Water)
   //
 
   const Int_t kNdet    = kNplan * kNcham;
@@ -135,20 +184,51 @@ void AliTRDgeometryFull::CreateGeometry(Int_t *idtmed)
   AliTRDgeometry::CreateGeometry(idtmed);
 
   // The TRD mother volume for one sector (Air), full length in z-direction
+  // Provides material for side plates of super module
   parTrd[0] = fgkSwidth1/2.;
   parTrd[1] = fgkSwidth2/2.;
   parTrd[2] = fgkSlenTR1/2.;
   parTrd[3] = fgkSheight/2.;
   gMC->Gsvolu("UTR1","TRD1",idtmed[1302-1],parTrd,kNparTrd);
-
-  // The TRD mother volume for one sector (Air), leaving hole for PHOS
+  // The TRD mother volume for one sector (Al), leaving hole for PHOS
   if (fPHOShole) {
     gMC->Gsvolu("UTR2","TRD1",idtmed[1302-1],parTrd,kNparTrd);
   }
+  // The TRD mother volume for one sector (Al), leaving hole for RICH
+  if (fRICHhole) {
+    gMC->Gsvolu("UTR3","TRD1",idtmed[1302-1],parTrd,kNparTrd);
+  }  
+
+  // 
+  // The side plates of the super module (Al)
+  parTrd[0] = fgkSwidth1/2. - fgkSMgapT;
+  parTrd[1] = fgkSwidth2/2. - fgkSMgapT;
+  parTrd[2] = fgkSlenTR1/2.;
+  parTrd[3] = fgkSheight/2.;
+  gMC->Gsvolu("UTS1","TRD1",idtmed[1301-1],parTrd,kNparTrd);
+  // The TRD mother volume for one sector (Al), leaving hole for PHOS
+  if (fPHOShole) {
+    gMC->Gsvolu("UTS2","TRD1",idtmed[1301-1],parTrd,kNparTrd);
+  }
+  // The TRD mother volume for one sector (Al), leaving hole for RICH
+  if (fRICHhole) {
+    gMC->Gsvolu("UTS3","TRD1",idtmed[1301-1],parTrd,kNparTrd);
+  }  
 
+  // The inner part of the TRD mother volume for one sector (Air), 
+  // full length in z-direction
+  parTrd[0] = fgkSwidth1/2. - fgkSMgapT - fgkSMpltT;
+  parTrd[1] = fgkSwidth2/2. - fgkSMgapT - fgkSMpltT;
+  parTrd[2] = fgkSlenTR1/2.;
+  parTrd[3] = fgkSheight/2.;
+  gMC->Gsvolu("UTI1","TRD1",idtmed[1302-1],parTrd,kNparTrd);
+  // The TRD mother volume for one sector (Air), leaving hole for PHOS
+  if (fPHOShole) {
+    gMC->Gsvolu("UTI2","TRD1",idtmed[1302-1],parTrd,kNparTrd);
+  }
   // The TRD mother volume for one sector (Air), leaving hole for RICH
   if (fRICHhole) {
-    gMC->Gsvolu("UTR3","TRD1",idtmed[1302-1],parTrd,kNparTrd);
+    gMC->Gsvolu("UTI3","TRD1",idtmed[1302-1],parTrd,kNparTrd);
   }  
 
   for (Int_t icham = 0; icham < kNcham; icham++) {
@@ -220,7 +300,7 @@ void AliTRDgeometryFull::CreateGeometry(Int_t *idtmed)
        }
       }
 
-      // The upper part of the readout chambers (readout plane + fee)
+      // The upper part of the readout chambers (readout plane)
       // The G10 frames
       sprintf(cTagV,"UD%02d",iDet);
       parCha[0] = fCwidth[iplan]/2. + fgkCroW;
@@ -327,18 +407,6 @@ void AliTRDgeometryFull::CreateGeometry(Int_t *idtmed)
       parCha[2] = fgkSuThick/2;
       sprintf(cTagV,"UM%02d",iDet);
       gMC->Gsvolu(cTagV,"BOX ",idtmed[1313-1],parCha,kNparCha);
-      // Cu layer (FEE + signal lines)
-      parCha[2] = fgkFeThick/2;
-      sprintf(cTagV,"UN%02d",iDet);
-      gMC->Gsvolu(cTagV,"BOX ",idtmed[1305-1],parCha,kNparCha);
-      // Al layer (cooling devices)
-      parCha[2] = fgkCoThick/2;
-      sprintf(cTagV,"UO%02d",iDet);
-      gMC->Gsvolu(cTagV,"BOX ",idtmed[1301-1],parCha,kNparCha);
-      // Water layer (cooling)
-      parCha[2] = fgkWaThick/2;
-      sprintf(cTagV,"UP%02d",iDet);
-      gMC->Gsvolu(cTagV,"BOX ",idtmed[1314-1],parCha,kNparCha);
       if (fPHOShole) {
         if (fClengthPH[iplan][icham] > 0.0) {
           // Rohacell layer (radiator)
@@ -365,18 +433,6 @@ void AliTRDgeometryFull::CreateGeometry(Int_t *idtmed)
           parCha[2] = fgkSuThick/2;
           sprintf(cTagV,"UM%02d",iDet+kNdet);
           gMC->Gsvolu(cTagV,"BOX ",idtmed[1313-1],parCha,kNparCha);
-          // Cu layer (FEE + signal lines)
-          parCha[2] = fgkFeThick/2;
-          sprintf(cTagV,"UN%02d",iDet+kNdet);
-          gMC->Gsvolu(cTagV,"BOX ",idtmed[1305-1],parCha,kNparCha);
-          // Al layer (cooling devices)
-          parCha[2] = fgkCoThick/2;
-          sprintf(cTagV,"UO%02d",iDet+kNdet);
-          gMC->Gsvolu(cTagV,"BOX ",idtmed[1301-1],parCha,kNparCha);
-          // Water layer (cooling)
-          parCha[2] = fgkWaThick/2;
-          sprintf(cTagV,"UP%02d",iDet+kNdet);
-          gMC->Gsvolu(cTagV,"BOX ",idtmed[1314-1],parCha,kNparCha);
        }
       }
       if (fRICHhole) {
@@ -405,18 +461,6 @@ void AliTRDgeometryFull::CreateGeometry(Int_t *idtmed)
           parCha[2] = fgkSuThick/2;
           sprintf(cTagV,"UM%02d",iDet+2*kNdet);
           gMC->Gsvolu(cTagV,"BOX ",idtmed[1313-1],parCha,kNparCha);
-          // Cu layer (FEE + signal lines)
-          parCha[2] = fgkFeThick/2;
-          sprintf(cTagV,"UN%02d",iDet+2*kNdet);
-          gMC->Gsvolu(cTagV,"BOX ",idtmed[1305-1],parCha,kNparCha);
-          // Al layer (cooling devices)
-          parCha[2] = fgkCoThick/2;
-          sprintf(cTagV,"UO%02d",iDet+2*kNdet);
-          gMC->Gsvolu(cTagV,"BOX ",idtmed[1301-1],parCha,kNparCha);
-          // Water layer (cooling)
-          parCha[2] = fgkWaThick/2;
-          sprintf(cTagV,"UP%02d",iDet+2*kNdet);
-          gMC->Gsvolu(cTagV,"BOX ",idtmed[1314-1],parCha,kNparCha);
        }
       }
 
@@ -456,21 +500,6 @@ void AliTRDgeometryFull::CreateGeometry(Int_t *idtmed)
       sprintf(cTagV,"UM%02d",iDet);
       sprintf(cTagM,"UG%02d",iDet);
       gMC->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
-      // Cu layer (FEE + signal lines)
-      zpos = fgkFeZpos; 
-      sprintf(cTagV,"UN%02d",iDet);
-      sprintf(cTagM,"UG%02d",iDet);
-      gMC->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
-      // Al layer (cooling devices)
-      zpos = fgkCoZpos;
-      sprintf(cTagV,"UO%02d",iDet);
-      sprintf(cTagM,"UG%02d",iDet);
-      gMC->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
-      // Water layer (cooling)
-      zpos = fgkWaZpos;
-      sprintf(cTagV,"UP%02d",iDet);
-      sprintf(cTagM,"UG%02d",iDet);
-      gMC->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
       if (fPHOShole) {
         if (fClengthPH[iplan][icham] > 0.0) {
           // Lower part
@@ -506,21 +535,6 @@ void AliTRDgeometryFull::CreateGeometry(Int_t *idtmed)
           sprintf(cTagV,"UM%02d",iDet+kNdet);
           sprintf(cTagM,"UG%02d",iDet+kNdet);
           gMC->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
-          // Cu layer (FEE + signal lines)
-          zpos = fgkFeZpos; 
-          sprintf(cTagV,"UN%02d",iDet+kNdet);
-          sprintf(cTagM,"UG%02d",iDet+kNdet);
-          gMC->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
-          // Al layer (cooling devices)
-          zpos = fgkCoZpos;
-          sprintf(cTagV,"UO%02d",iDet+kNdet);
-          sprintf(cTagM,"UG%02d",iDet+kNdet);
-          gMC->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
-          // Water layer (cooling)
-          zpos = fgkWaZpos;
-          sprintf(cTagV,"UP%02d",iDet+kNdet);
-          sprintf(cTagM,"UG%02d",iDet+kNdet);
-          gMC->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
        }
       }
       if (fRICHhole) {
@@ -558,21 +572,6 @@ void AliTRDgeometryFull::CreateGeometry(Int_t *idtmed)
           sprintf(cTagV,"UM%02d",iDet+2*kNdet);
           sprintf(cTagM,"UG%02d",iDet+2*kNdet);
           gMC->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
-          // Cu layer (FEE + signal lines)
-          zpos = fgkFeZpos; 
-          sprintf(cTagV,"UN%02d",iDet+2*kNdet);
-          sprintf(cTagM,"UG%02d",iDet+2*kNdet);
-          gMC->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
-          // Al layer (cooling devices)
-          zpos = fgkCoZpos;
-          sprintf(cTagV,"UO%02d",iDet+2*kNdet);
-          sprintf(cTagM,"UG%02d",iDet+2*kNdet);
-          gMC->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
-          // Water layer (cooling)
-          zpos = fgkWaZpos;
-          sprintf(cTagV,"UP%02d",iDet+2*kNdet);
-          sprintf(cTagM,"UG%02d",iDet+2*kNdet);
-          gMC->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
        }
       }
 
@@ -647,15 +646,15 @@ void AliTRDgeometryFull::CreateGeometry(Int_t *idtmed)
       zpos  = fgkCraH/2. + fgkCdrH/2. - fgkSheight/2. + iplan * (fgkCH + fgkVspace);
       // The lower aluminum frame, radiator + drift region
       sprintf(cTagV,"UA%02d",iDet);
-      gMC->Gspos(cTagV,1,"UTR1",xpos,ypos,zpos,0,"ONLY");
+      gMC->Gspos(cTagV,1,"UTI1",xpos,ypos,zpos,0,"ONLY");
       // The upper G10 frame, amplification region
       sprintf(cTagV,"UD%02d",iDet);
       zpos += fgkCamH/2. + fgkCraH/2. + fgkCdrH/2.;
-      gMC->Gspos(cTagV,1,"UTR1",xpos,ypos,zpos,0,"ONLY");
+      gMC->Gspos(cTagV,1,"UTI1",xpos,ypos,zpos,0,"ONLY");
       // The upper aluminum frame
       sprintf(cTagV,"UF%02d",iDet);
       zpos += fgkCroH/2. + fgkCamH/2.;
-      gMC->Gspos(cTagV,1,"UTR1",xpos,ypos,zpos,0,"ONLY");
+      gMC->Gspos(cTagV,1,"UTI1",xpos,ypos,zpos,0,"ONLY");
       if (fPHOShole) {
         if (fClengthPH[iplan][icham] > 0.0) {
           xpos  = 0.;
@@ -673,15 +672,15 @@ void AliTRDgeometryFull::CreateGeometry(Int_t *idtmed)
           zpos  = fgkCraH/2. + fgkCdrH/2. - fgkSheight/2. + iplan * (fgkCH + fgkVspace);
           // The lower aluminum frame, radiator + drift region
           sprintf(cTagV,"UA%02d",iDet+kNdet);
-          gMC->Gspos(cTagV,1,"UTR2",xpos,ypos,zpos,0,"ONLY");
+          gMC->Gspos(cTagV,1,"UTI2",xpos,ypos,zpos,0,"ONLY");
           // The upper G10 frame, amplification region
           sprintf(cTagV,"UD%02d",iDet+kNdet);
           zpos += fgkCamH/2. + fgkCraH/2. + fgkCdrH/2.;
-          gMC->Gspos(cTagV,1,"UTR2",xpos,ypos,zpos,0,"ONLY");
+          gMC->Gspos(cTagV,1,"UTI2",xpos,ypos,zpos,0,"ONLY");
           // The upper aluminum frame
           sprintf(cTagV,"UF%02d",iDet+kNdet);
           zpos += fgkCroH/2. + fgkCamH/2.;
-          gMC->Gspos(cTagV,1,"UTR2",xpos,ypos,zpos,0,"ONLY");
+          gMC->Gspos(cTagV,1,"UTI2",xpos,ypos,zpos,0,"ONLY");
        }
       }
       if (fRICHhole) {
@@ -701,21 +700,43 @@ void AliTRDgeometryFull::CreateGeometry(Int_t *idtmed)
           zpos  = fgkCraH/2. + fgkCdrH/2. - fgkSheight/2. + iplan * (fgkCH + fgkVspace);
           // The lower aluminum frame, radiator + drift region
           sprintf(cTagV,"UA%02d",iDet+2*kNdet);
-          gMC->Gspos(cTagV,1,"UTR3",xpos,ypos,zpos,0,"ONLY");
+          gMC->Gspos(cTagV,1,"UTI3",xpos,ypos,zpos,0,"ONLY");
           // The upper G10 frame, amplification region
           sprintf(cTagV,"UD%02d",iDet+2*kNdet);
           zpos += fgkCamH/2. + fgkCraH/2. + fgkCdrH/2.;
-          gMC->Gspos(cTagV,1,"UTR3",xpos,ypos,zpos,0,"ONLY");
+          gMC->Gspos(cTagV,1,"UTI3",xpos,ypos,zpos,0,"ONLY");
           // The upper aluminum frame
           sprintf(cTagV,"UF%02d",iDet+2*kNdet);
           zpos += fgkCroH/2. + fgkCamH/2.;
-          gMC->Gspos(cTagV,1,"UTR3",xpos,ypos,zpos,0,"ONLY");
+          gMC->Gspos(cTagV,1,"UTI3",xpos,ypos,zpos,0,"ONLY");
        }
       }
 
     }
   }
 
+  xpos = 0.;
+  ypos = 0.;
+  zpos = 0.;
+  gMC->Gspos("UTI1",1,"UTS1",xpos,ypos,zpos,0,"ONLY");
+  if (fPHOShole) {
+    gMC->Gspos("UTI2",2,"UTS2",xpos,ypos,zpos,0,"ONLY");
+  }
+  if (fRICHhole) {
+    gMC->Gspos("UTI3",3,"UTS3",xpos,ypos,zpos,0,"ONLY");
+  }
+
+  xpos = 0.;
+  ypos = 0.;
+  zpos = 0.;
+  gMC->Gspos("UTS1",1,"UTR1",xpos,ypos,zpos,0,"ONLY");
+  if (fPHOShole) {
+    gMC->Gspos("UTS2",2,"UTR2",xpos,ypos,zpos,0,"ONLY");
+  }
+  if (fRICHhole) {
+    gMC->Gspos("UTS3",3,"UTR3",xpos,ypos,zpos,0,"ONLY");
+  }
+
   xpos = 0.;
   ypos = 0.;
   zpos = 0.;
@@ -733,6 +754,622 @@ void AliTRDgeometryFull::CreateGeometry(Int_t *idtmed)
     gMC->Gspos("UTR1",3,"BTR3",xpos,ypos,zpos,0,"ONLY");
   }
 
+  // Create the volumes of the super module frame
+  CreateFrame(idtmed);
+
+  // Create the volumes of the services
+  CreateServices(idtmed);
+
+}
+
+//_____________________________________________________________________________
+void AliTRDgeometryFull::CreateFrame(Int_t *idtmed)
+{
+  //
+  // Create the geometry of the frame of the supermodule
+  //
+  // Names of the TRD services volumina
+  //
+  //        USRL    Support rails for the chambers (Al)
+  //        USxx    Support cross bars between the chambers (Al)
+  //
+
+  Int_t   iplan = 0;
+
+  Float_t xpos  = 0.0;
+  Float_t ypos  = 0.0;
+  Float_t zpos  = 0.0;
+
+  Char_t  cTagV[5];
+
+  //
+  // The chamber support rails
+  //
+
+  const Float_t kSRLwid  = 2.0;
+  const Float_t kSRLhgt  = 2.3;
+  const Float_t kSRLdst  = 0.6;
+  const Int_t   kNparSRL = 3;
+  Float_t parSRL[kNparSRL];
+  parSRL[0] = kSRLwid/2.;
+  parSRL[1] = fgkSlenTR1/2.;
+  parSRL[2] = kSRLhgt/2.;
+  gMC->Gsvolu("USRL","BOX ",idtmed[1301-1],parSRL,kNparSRL);
+
+  xpos  = 0.0;
+  ypos  = 0.0;
+  zpos  = 0.0;
+  for (iplan = 0; iplan < kNplan; iplan++) {
+    
+    xpos  = fCwidth[iplan]/2. + kSRLwid/2. + kSRLdst;
+    ypos  = 0.0;
+    zpos  = fgkCraH + fgkCdrH - fgkSheight/2. - kSRLhgt/2. 
+          + iplan * (fgkCH + fgkVspace);
+    gMC->Gspos("USRL",iplan+1         ,"UTI1", xpos,ypos,zpos,0,"ONLY");
+    gMC->Gspos("USRL",iplan+1+  kNplan,"UTI1",-xpos,ypos,zpos,0,"ONLY");
+    if (fPHOShole) {
+      gMC->Gspos("USRL",iplan+1+2*kNplan,"UTI2", xpos,ypos,zpos,0,"ONLY");
+      gMC->Gspos("USRL",iplan+1+3*kNplan,"UTI2",-xpos,ypos,zpos,0,"ONLY");
+    }
+    if (fRICHhole) {
+      gMC->Gspos("USRL",iplan+1+4*kNplan,"UTI3", xpos,ypos,zpos,0,"ONLY");
+      gMC->Gspos("USRL",iplan+1+5*kNplan,"UTI3",-xpos,ypos,zpos,0,"ONLY");
+    }
+
+  }
+
+  //
+  // The cross bars between the chambers
+  //
+
+  const Float_t kSCBwid  = 1.0;
+  const Int_t   kNparSCB = 3;
+  Float_t parSCB[kNparSCB];
+  parSCB[1] = kSCBwid/2.;
+  parSCB[2] = fgkCH/2.;
+
+  xpos  = 0.0;
+  ypos  = 0.0;
+  zpos  = 0.0;
+  for (iplan = 0; iplan < kNplan; iplan++) {
+
+    parSCB[0] = fCwidth[iplan]/2. + kSRLdst/2.;
+
+    sprintf(cTagV,"US0%01d",iplan);
+    gMC->Gsvolu(cTagV,"BOX ",idtmed[1301-1],parSCB,kNparSCB);
+    xpos  = 0.0;
+    ypos  =   fgkSlenTR1/2. - kSCBwid/2.;
+    zpos  = fgkCH/2. - fgkSheight/2. + iplan * (fgkCH + fgkVspace);
+    gMC->Gspos(cTagV,1,"UTI1", xpos,ypos,zpos,0,"ONLY");
+    if (fPHOShole) {
+      gMC->Gspos(cTagV,2,"UTI2", xpos,ypos,zpos,0,"ONLY");
+    }
+    if (fRICHhole) {
+      gMC->Gspos(cTagV,3,"UTI3", xpos,ypos,zpos,0,"ONLY");
+    }
+
+    sprintf(cTagV,"US1%01d",iplan);
+    gMC->Gsvolu(cTagV,"BOX ",idtmed[1301-1],parSCB,kNparSCB);
+    xpos  = 0.0;
+    ypos  = fClength[iplan][2]/2. + fClength[iplan][1];
+    zpos  = fgkCH/2. - fgkSheight/2. + iplan * (fgkCH + fgkVspace);
+    gMC->Gspos(cTagV,1,"UTI1", xpos,ypos,zpos,0,"ONLY");
+    if (fPHOShole) {
+      gMC->Gspos(cTagV,2,"UTI2", xpos,ypos,zpos,0,"ONLY");
+    }
+    if (fRICHhole) {
+      ypos += fClength[iplan][0] - fClengthRH[iplan][0];
+      gMC->Gspos(cTagV,3,"UTI3", xpos,ypos,zpos,0,"ONLY");
+    }
+
+    sprintf(cTagV,"US2%01d",iplan);
+    gMC->Gsvolu(cTagV,"BOX ",idtmed[1301-1],parSCB,kNparSCB);
+    xpos  = 0.0;
+    ypos  = fClength[iplan][2]/2.;
+    zpos  = fgkCH/2. - fgkSheight/2. + iplan * (fgkCH + fgkVspace);
+    gMC->Gspos(cTagV,1,"UTI1", xpos,ypos,zpos,0,"ONLY");
+    if (fPHOShole) {
+      ypos += fClength[iplan][1] - fClengthPH[iplan][1];
+      gMC->Gspos(cTagV,2,"UTI2", xpos,ypos,zpos,0,"ONLY");
+    }
+
+    sprintf(cTagV,"US3%01d",iplan);
+    gMC->Gsvolu(cTagV,"BOX ",idtmed[1301-1],parSCB,kNparSCB);
+    xpos  = 0.0;
+    ypos  = - fClength[iplan][2]/2.;
+    zpos  = fgkCH/2. - fgkSheight/2. + iplan * (fgkCH + fgkVspace);
+    gMC->Gspos(cTagV,1,"UTI1", xpos,ypos,zpos,0,"ONLY");
+    if (fPHOShole) {
+      ypos -= fClength[iplan][3] - fClengthPH[iplan][3];
+      gMC->Gspos(cTagV,2,"UTI2", xpos,ypos,zpos,0,"ONLY");
+    }
+
+    sprintf(cTagV,"US4%01d",iplan);
+    gMC->Gsvolu(cTagV,"BOX ",idtmed[1301-1],parSCB,kNparSCB);
+    xpos  = 0.0;
+    ypos  = - fClength[iplan][2]/2. - fClength[iplan][1];
+    zpos  = fgkCH/2. - fgkSheight/2. + iplan * (fgkCH + fgkVspace);
+    gMC->Gspos(cTagV,1,"UTI1", xpos,ypos,zpos,0,"ONLY");
+    if (fPHOShole) {
+      gMC->Gspos(cTagV,2,"UTI2", xpos,ypos,zpos,0,"ONLY");
+    }
+    if (fRICHhole) {
+      ypos -= fClength[iplan][4] - fClengthRH[iplan][4];
+      gMC->Gspos(cTagV,3,"UTI3", xpos,ypos,zpos,0,"ONLY");
+    }
+
+    sprintf(cTagV,"US5%01d",iplan);
+    gMC->Gsvolu(cTagV,"BOX ",idtmed[1301-1],parSCB,kNparSCB);
+    xpos  = 0.0;
+    ypos  = - fgkSlenTR1/2. + kSCBwid/2.;
+    zpos  = fgkCH/2. - fgkSheight/2. + iplan * (fgkCH + fgkVspace);
+    gMC->Gspos(cTagV,1,"UTI1", xpos,ypos,zpos,0,"ONLY");
+    if (fPHOShole) {
+      gMC->Gspos(cTagV,2,"UTI2", xpos,ypos,zpos,0,"ONLY");
+    }
+    if (fRICHhole) {
+      gMC->Gspos(cTagV,3,"UTI3", xpos,ypos,zpos,0,"ONLY");
+    }
+
+  }
+
+}
+
+//_____________________________________________________________________________
+void AliTRDgeometryFull::CreateServices(Int_t *idtmed)
+{
+  //
+  // Create the geometry of the services
+  //
+  // Names of the TRD services volumina
+  //
+  //        UTCL    Cooling arterias (Al)
+  //        UTCW    Cooling arterias (Water)
+  //        UUxx    Volumes for the services at the chambers (Air)
+  //        UTPW    Power bars       (Cu)
+  //        UTCP    Cooling pipes    (Al)
+  //        UTCH    Cooling pipes    (Water)
+  //        UTPL    Power lines      (Cu)
+  //        UMCM    Readout MCMs     (G10/Cu/Si)
+  //
+
+  const Int_t kNdet = kNplan * kNcham;
+
+  Int_t   iplan = 0;
+  Int_t   icham = 0;
+
+  Float_t xpos  = 0.0;
+  Float_t ypos  = 0.0;
+  Float_t zpos  = 0.0;
+
+  Char_t  cTagV[5];
+
+  // The rotation matrices
+  const Int_t kNmatrix = 3;
+  Int_t   matrix[kNmatrix];
+  gMC->Matrix(matrix[0],100.0,0.0,90.0,90.0, 0.0,0.0);
+  gMC->Matrix(matrix[1], 80.0,0.0,90.0,90.0, 0.0,0.0);
+  gMC->Matrix(matrix[2],  0.0,0.0,90.0,90.0,90.0,0.0);
+
+  AliTRDparameter *parameter = new AliTRDparameter("par","TRD parameter");
+
+  //
+  // The cooling arterias
+  //
+
+  // Width of the cooling arterias
+  const Float_t kCOLwid  =  0.5; 
+  // Height of the cooling arterias
+  const Float_t kCOLhgt  =  5.5;
+  // Positioning of the cooling 
+  const Float_t kCOLposx =  1.6;
+  const Float_t kCOLposz = -0.2;
+  // Thickness of the walls of the cooling arterias
+  const Float_t kCOLthk  =  0.1;
+  const Int_t   kNparCOL = 3;
+  Float_t parCOL[kNparCOL];
+  parCOL[0]  = kCOLwid/2.;
+  parCOL[1]  = fgkSlenTR1/2.;
+  parCOL[2]  = kCOLhgt/2.;
+  gMC->Gsvolu("UTCL","BOX ",idtmed[1324-1],parCOL,kNparCOL);
+  parCOL[0] -= kCOLthk;
+  parCOL[1]  = fgkSlenTR1/2.;
+  parCOL[2] -= kCOLthk;
+  gMC->Gsvolu("UTCW","BOX ",idtmed[1314-1],parCOL,kNparCOL);
+
+  xpos  = 0.0;
+  ypos  = 0.0;
+  zpos  = 0.0;
+  gMC->Gspos("UTCW",1,"UTCL", xpos,ypos,zpos,0,"ONLY");
+
+  for (iplan = 1; iplan < kNplan; iplan++) {
+    
+    xpos  = fCwidth[iplan]/2. + kCOLwid/2. + kCOLposx;
+    ypos  = 0.0;
+    zpos  = kCOLhgt/2. - fgkSheight/2. + kCOLposz + iplan * (fgkCH + fgkVspace);
+    gMC->Gspos("UTCL",iplan+1         ,"UTI1", xpos,ypos,zpos,matrix[0],"ONLY");
+    gMC->Gspos("UTCL",iplan+1+  kNplan,"UTI1",-xpos,ypos,zpos,matrix[1],"ONLY");
+    if (fPHOShole) {
+      gMC->Gspos("UTCL",iplan+1+2*kNplan,"UTI2", xpos,ypos,zpos,matrix[0],"ONLY");
+      gMC->Gspos("UTCL",iplan+1+3*kNplan,"UTI2",-xpos,ypos,zpos,matrix[1],"ONLY");
+    }
+    if (fRICHhole) {
+      gMC->Gspos("UTCL",iplan+1+4*kNplan,"UTI3", xpos,ypos,zpos,matrix[0],"ONLY");
+      gMC->Gspos("UTCL",iplan+1+5*kNplan,"UTI3",-xpos,ypos,zpos,matrix[1],"ONLY");
+    }
+
+  }
+
+  //
+  // The power bars
+  //
+
+  const Float_t kPWRwid  =  0.6;
+  const Float_t kPWRhgt  =  4.5;
+  const Float_t kPWRposx =  1.05;
+  const Float_t kPWRposz =  0.9;
+  const Int_t   kNparPWR = 3;
+  Float_t parPWR[kNparPWR];
+  parPWR[0] = kPWRwid/2.;
+  parPWR[1] = fgkSlenTR1/2.;
+  parPWR[2] = kPWRhgt/2.;
+  gMC->Gsvolu("UTPW","BOX ",idtmed[1325-1],parPWR,kNparPWR);
+
+  for (iplan = 1; iplan < kNplan; iplan++) {
+    
+    xpos  = fCwidth[iplan]/2. + kPWRwid/2. + kPWRposx;
+    ypos  = 0.0;
+    zpos  = kPWRhgt/2. - fgkSheight/2. + kPWRposz + iplan * (fgkCH + fgkVspace);
+    gMC->Gspos("UTPW",iplan+1         ,"UTI1", xpos,ypos,zpos,matrix[0],"ONLY");
+    gMC->Gspos("UTPW",iplan+1+  kNplan,"UTI1",-xpos,ypos,zpos,matrix[1],"ONLY");
+    if (fPHOShole) {
+      gMC->Gspos("UTPW",iplan+1+2*kNplan,"UTI2", xpos,ypos,zpos,matrix[0],"ONLY");
+      gMC->Gspos("UTPW",iplan+1+3*kNplan,"UTI2",-xpos,ypos,zpos,matrix[1],"ONLY");
+    }
+    if (fRICHhole) {
+      gMC->Gspos("UTPW",iplan+1+4*kNplan,"UTI3", xpos,ypos,zpos,matrix[0],"ONLY");
+      gMC->Gspos("UTPW",iplan+1+5*kNplan,"UTI3",-xpos,ypos,zpos,matrix[1],"ONLY");
+    }
+
+  }
+
+  //
+  // The volumes for the services at the chambers
+  //
+
+  const Int_t kNparServ = 3;
+  Float_t parServ[kNparServ];
+
+  for (icham = 0; icham < kNcham; icham++) {
+    //for (iplan = 0; iplan < kNplan; iplan++) {
+    // Take out upper plane until TRD mothervolume is adjusted
+    for (iplan = 0; iplan < kNplan-1; iplan++) {
+
+      Int_t iDet = GetDetectorSec(iplan,icham);
+
+      sprintf(cTagV,"UU%02d",iDet);
+      parServ[0] = fCwidth[iplan]/2.;
+      parServ[1] = fClength[iplan][icham]/2. - fgkHspace/2.;
+      parServ[2] = fgkVspace/2.;
+      gMC->Gsvolu(cTagV,"BOX",idtmed[1302-1],parServ,kNparServ);
+      xpos  = 0.;
+      ypos  = - fClength[iplan][0] - fClength[iplan][1] - fClength[iplan][2]/2.;
+      for (Int_t ic = 0; ic < icham; ic++) {
+        ypos += fClength[iplan][ic];        
+      }
+      ypos += fClength[iplan][icham]/2.;
+      zpos  = fgkCH + fgkVspace/2. - fgkSheight/2. + iplan * (fgkCH + fgkVspace);
+      gMC->Gspos(cTagV,1,"UTI1",xpos,ypos,zpos,0,"ONLY");
+
+      if (fPHOShole) {
+        if (fClengthPH[iplan][icham] > 0.0) {
+          sprintf(cTagV,"UU%02d",iDet+kNdet);
+          parServ[0] = fCwidth[iplan]/2.;
+          parServ[1] = fClengthPH[iplan][icham]/2. - fgkHspace/2.;
+          parServ[2] = fgkVspace/2.;
+          gMC->Gsvolu(cTagV,"BOX",idtmed[1302-1],parServ,kNparServ);
+          xpos  = 0.;
+          ypos  = - fClength[iplan][0] - fClength[iplan][1] - fClength[iplan][2]/2.;
+          for (Int_t ic = 0; ic < icham; ic++) {
+            ypos += fClength[iplan][ic];        
+          }
+          if (icham > 2) {
+            ypos += fClength[iplan][icham];
+            ypos -= fClengthPH[iplan][icham]/2.;
+         }
+          else {
+            ypos += fClengthPH[iplan][icham]/2.;
+         }
+          zpos  = fgkCH + fgkVspace/2. - fgkSheight/2. + iplan * (fgkCH + fgkVspace);
+          gMC->Gspos(cTagV,1,"UTI2",xpos,ypos,zpos,0,"ONLY");
+       }
+      }
+
+      if (fRICHhole) {
+        if (fClengthRH[iplan][icham] > 0.0) {
+          sprintf(cTagV,"UU%02d",iDet+2*kNdet);
+          parServ[0] = fCwidth[iplan]/2.;
+          parServ[1] = fClengthRH[iplan][icham]/2. - fgkHspace/2.;
+          parServ[2] = fgkVspace/2.;
+          gMC->Gsvolu(cTagV,"BOX",idtmed[1302-1],parServ,kNparServ);
+          xpos  = 0.;
+          ypos  = - fClength[iplan][0] - fClength[iplan][1] - fClength[iplan][2]/2.;
+          for (Int_t ic = 0; ic < icham; ic++) {
+            ypos += fClength[iplan][ic];        
+          }
+          if (icham > 2) {
+            ypos += fClength[iplan][icham];
+            ypos -= fClengthRH[iplan][icham]/2.;
+         }
+          else {
+            ypos += fClengthRH[iplan][icham]/2.;
+         }
+          zpos  = fgkCH + fgkVspace/2. - fgkSheight/2. + iplan * (fgkCH + fgkVspace);
+          gMC->Gspos(cTagV,1,"UTI3",xpos,ypos,zpos,0,"ONLY");
+       }
+      }
+
+    }
+  }
+
+  //
+  // The cooling pipes inside the service volumes
+  //
+
+  const Int_t kNparTube = 3;
+  Float_t parTube[kNparTube];
+  // The aluminum pipe for the cooling
+  parTube[0] = 0.0;
+  parTube[1] = 0.0;
+  parTube[2] = 0.0;
+  gMC->Gsvolu("UTCP","TUBE",idtmed[1324-1],parTube,0);
+  // The cooling water
+  parTube[0] =  0.0;
+  parTube[1] =  0.2/2.;
+  parTube[2] = -1.;
+  gMC->Gsvolu("UTCH","TUBE",idtmed[1314-1],parTube,kNparTube);
+  // Water inside the cooling pipe
+  xpos = 0.0;
+  ypos = 0.0;
+  zpos = 0.0;
+  gMC->Gspos("UTCH",1,"UTCP",xpos,ypos,zpos,0,"ONLY");
+
+  // Position the cooling pipes in the mother volume
+  const Int_t kNpar = 3;
+  Float_t par[kNpar];
+  for (icham = 0; icham < kNcham;   icham++) {
+    //for (iplan = 0; iplan < kNplan; iplan++) {
+    // Take out upper plane until TRD mothervolume is adjusted
+    for (iplan = 0; iplan < kNplan-1; iplan++) { 
+      Int_t   iDet    = GetDetectorSec(iplan,icham);
+      Int_t   iCopy   = GetDetector(iplan,icham,0) * 100;
+      Int_t   nMCMrow = parameter->GetRowMax(iplan,icham,0);
+      Float_t ySize   = (GetChamberLength(iplan,icham) - 2.*fgkRpadW) 
+                      / ((Float_t) nMCMrow);
+      sprintf(cTagV,"UU%02d",iDet);
+      for (Int_t iMCMrow = 0; iMCMrow < nMCMrow; iMCMrow++) {
+        xpos   = 0.0;
+        ypos   = (0.5 + iMCMrow) * ySize - 1.9 
+               - fClength[iplan][icham]/2. + fgkHspace/2.;
+        zpos   = 0.0;                 
+        par[0] = 0.0;
+        par[1] = 0.3/2.; // Thickness of the cooling pipes
+        par[2] = fCwidth[iplan]/2.;
+        gMC->Gsposp("UTCP",iCopy+iMCMrow,cTagV,xpos,ypos,zpos
+                          ,matrix[2],"ONLY",par,kNpar);
+      }
+      if (fPHOShole) {
+        sprintf(cTagV,"UU%02d",iDet+kNdet);
+        for (Int_t iMCMrow = 0; iMCMrow < nMCMrow; iMCMrow++) {
+          xpos   = 0.0;
+          ypos   = (0.5 + iMCMrow) * ySize - 1.9 
+                 - fClengthPH[iplan][icham]/2. + fgkHspace/2.;
+          zpos   = 0.0;                 
+          if (ypos < (fClengthPH[iplan][icham]/2. - fgkHspace/2.)) {
+            par[0] = 0.0;
+            par[1] = 0.3/2.; // Thickness of the cooling pipes
+            par[2] = fCwidth[iplan]/2.;
+            gMC->Gsposp("UTCP",iCopy+iMCMrow+nMCMrow,cTagV,xpos,ypos,zpos
+                              ,matrix[2],"ONLY",par,kNpar);
+         }
+       }
+      }
+      if (fRICHhole) {
+        sprintf(cTagV,"UU%02d",iDet+2*kNdet);
+        for (Int_t iMCMrow = 0; iMCMrow < nMCMrow; iMCMrow++) {
+          xpos   = 0.0;
+          ypos   = (0.5 + iMCMrow) * ySize - 1.9 
+                 - fClengthRH[iplan][icham]/2. + fgkHspace/2.;
+          zpos   = 0.0;                 
+          if (ypos < (fClengthRH[iplan][icham]/2. - fgkHspace/2.)) {
+            par[0] = 0.0;
+            par[1] = 0.3/2.; // Thickness of the cooling pipes
+            par[2] = fCwidth[iplan]/2.;
+            gMC->Gsposp("UTCP",iCopy+iMCMrow+2*nMCMrow,cTagV,xpos,ypos,zpos
+                              ,matrix[2],"ONLY",par,kNpar);
+         }
+       }
+      }
+    }
+  }
+
+  //
+  // The power lines
+  //
+
+  // The copper power lines
+  parTube[0] = 0.0;
+  parTube[1] = 0.0;
+  parTube[2] = 0.0;
+  gMC->Gsvolu("UTPL","TUBE",idtmed[1305-1],parTube,0);
+
+  // Position the power lines in the mother volume
+  for (icham = 0; icham < kNcham;   icham++) {
+    //for (iplan = 0; iplan < kNplan; iplan++) {
+    // Take out upper plane until TRD mothervolume is adjusted
+    for (iplan = 0; iplan < kNplan-1; iplan++) { 
+      Int_t   iDet    = GetDetectorSec(iplan,icham);
+      Int_t   iCopy   = GetDetector(iplan,icham,0) * 100;
+      Int_t   nMCMrow = parameter->GetRowMax(iplan,icham,0);
+      Float_t ySize   = (GetChamberLength(iplan,icham) - 2.*fgkRpadW) 
+                      / ((Float_t) nMCMrow);
+      sprintf(cTagV,"UU%02d",iDet);
+      for (Int_t iMCMrow = 0; iMCMrow < nMCMrow; iMCMrow++) {
+        xpos   = 0.0;
+        ypos   = (0.5 + iMCMrow) * ySize - 1.0 
+               - fClength[iplan][icham]/2. + fgkHspace/2.;
+        zpos   = -0.4;
+        par[0] = 0.0;
+        par[1] = 0.2/2.; // Thickness of the power lines
+        par[2] = fCwidth[iplan]/2.;
+        gMC->Gsposp("UTPL",iCopy+iMCMrow,cTagV,xpos,ypos,zpos
+                          ,matrix[2],"ONLY",par,kNpar);
+      }
+      if (fPHOShole) {
+        sprintf(cTagV,"UU%02d",iDet+kNdet);
+        for (Int_t iMCMrow = 0; iMCMrow < nMCMrow; iMCMrow++) {
+          xpos   = 0.0;
+          ypos   = (0.5 + iMCMrow) * ySize - 1.0 
+                 - fClengthPH[iplan][icham]/2. + fgkHspace/2.;
+          zpos   = -0.4;                 
+          if (ypos < (fClengthPH[iplan][icham]/2. - fgkHspace/2.)) {
+            par[0] = 0.0;
+            par[1] = 0.2/2.; // Thickness of the power lines
+            par[2] = fCwidth[iplan]/2.;
+            gMC->Gsposp("UTPL",iCopy+iMCMrow+nMCMrow,cTagV,xpos,ypos,zpos
+                              ,matrix[2],"ONLY",par,kNpar);
+         }
+       }
+      }
+      if (fRICHhole) {
+        sprintf(cTagV,"UU%02d",iDet+2*kNdet);
+        for (Int_t iMCMrow = 0; iMCMrow < nMCMrow; iMCMrow++) {
+          xpos   = 0.0;
+          ypos   = (0.5 + iMCMrow) * ySize - 1.0 
+                 - fClengthRH[iplan][icham]/2. + fgkHspace/2.;
+          zpos   = -0.4;                 
+          if (ypos < (fClengthRH[iplan][icham]/2. - fgkHspace/2.)) {
+            par[0] = 0.0;
+            par[1] = 0.2/2.; // Thickness of the power lines
+            par[2] = fCwidth[iplan]/2.;
+            gMC->Gsposp("UTPL",iCopy+iMCMrow+2*nMCMrow,cTagV,xpos,ypos,zpos
+                              ,matrix[2],"ONLY",par,kNpar);
+         }
+       }
+      }
+    }
+  }
+
+  //
+  // The MCMs
+  //
+
+  // The mother volume for the MCMs (air)
+  const Int_t kNparMCM = 3;
+  Float_t parMCM[kNparMCM];
+  parMCM[0] = 3.0/2.;
+  parMCM[1] = 3.0/2.;
+  parMCM[2] = 0.14/2.;
+  gMC->Gsvolu("UMCM","BOX",idtmed[1302-1],parMCM,kNparMCM);
+
+  // The MCM carrier G10 layer
+  parMCM[0] = 3.0/2.;
+  parMCM[1] = 3.0/2.;
+  parMCM[2] = 0.1/2.;
+  gMC->Gsvolu("UMC1","BOX",idtmed[1319-1],parMCM,kNparMCM);
+  // The MCM carrier Cu layer
+  parMCM[0] = 3.0/2.;
+  parMCM[1] = 3.0/2.;
+  parMCM[2] = 0.0162/2.;
+  gMC->Gsvolu("UMC2","BOX",idtmed[1318-1],parMCM,kNparMCM);
+  // The silicon of the chips
+  parMCM[0] = 3.0/2.;
+  parMCM[1] = 3.0/2.;
+  parMCM[2] = 0.003/2.;
+  gMC->Gsvolu("UMC3","BOX",idtmed[1320-1],parMCM,kNparMCM);
+
+  // Put the MCM material inside the MCM mother volume
+  xpos  =  0.0;
+  ypos  =  0.0;
+  zpos  = -0.07      + 0.1/2.;
+  gMC->Gspos("UMC1",1,"UMCM",xpos,ypos,zpos,0,"ONLY");
+  zpos +=  0.1/2.    + 0.0162/2.;
+  gMC->Gspos("UMC2",1,"UMCM",xpos,ypos,zpos,0,"ONLY");
+  zpos +=  0.00162/2 + 0.003/2.;
+  gMC->Gspos("UMC3",1,"UMCM",xpos,ypos,zpos,0,"ONLY");
+
+  // Position the MCMs in the mother volume
+  for (icham = 0; icham < kNcham;   icham++) {
+    //for (iplan = 0; iplan < kNplan; iplan++) {
+    // Take out upper plane until TRD mothervolume is adjusted
+    for (iplan = 0; iplan < kNplan-1; iplan++) { 
+      Int_t   iDet    = GetDetectorSec(iplan,icham);
+      Int_t   iCopy   = GetDetector(iplan,icham,0) * 1000;
+      Int_t   nMCMrow = parameter->GetRowMax(iplan,icham,0);
+      Float_t ySize   = (GetChamberLength(iplan,icham) - 2.*fgkRpadW) 
+                      / ((Float_t) nMCMrow);
+      Int_t   nMCMcol = 8;
+      Float_t xSize   = (GetChamberWidth(iplan) - 2.* fgkCpadW)
+                     / ((Float_t) nMCMcol);
+      sprintf(cTagV,"UU%02d",iDet);
+      for (Int_t iMCMrow = 0; iMCMrow < nMCMrow; iMCMrow++) {
+        for (Int_t iMCMcol = 0; iMCMcol < nMCMcol; iMCMcol++) {
+          xpos   = (0.5 + iMCMcol) * xSize + 1.0 
+                 - fCwidth[iplan]/2.;
+          ypos   = (0.5 + iMCMrow) * ySize + 1.0 
+                 - fClength[iplan][icham]/2. + fgkHspace/2.;
+          zpos   = -0.4;
+          par[0] = 0.0;
+          par[1] = 0.2/2.; // Thickness of the power lines
+          par[2] = fCwidth[iplan]/2.;
+          gMC->Gspos("UMCM",iCopy+iMCMrow*10+iMCMcol,cTagV
+                           ,xpos,ypos,zpos,0,"ONLY");
+       }
+      }
+      if (fPHOShole) {
+        sprintf(cTagV,"UU%02d",iDet+kNdet);
+        for (Int_t iMCMrow = 0; iMCMrow < nMCMrow; iMCMrow++) {
+          for (Int_t iMCMcol = 0; iMCMcol < nMCMcol; iMCMcol++) {
+            xpos   = (0.5 + iMCMcol) * xSize + 1.0 
+                   - fCwidth[iplan]/2.;
+            ypos   = (0.5 + iMCMrow) * ySize + 1.0 
+                   - fClengthPH[iplan][icham]/2. + fgkHspace/2.;
+            zpos   = -0.4;
+            if (ypos < (fClengthPH[iplan][icham]/2. - fgkHspace/2.)) {
+              par[0] = 0.0;
+              par[1] = 0.2/2.; // Thickness of the power lines
+              par[2] = fCwidth[iplan]/2.;
+              gMC->Gspos("UMCM",iCopy+iMCMrow*10+iMCMcol+10*nMCMrow,cTagV
+                               ,xpos,ypos,zpos,0,"ONLY");
+           }
+         }
+        }
+      }
+      if (fPHOShole) {
+        sprintf(cTagV,"UU%02d",iDet+2*kNdet);
+        for (Int_t iMCMrow = 0; iMCMrow < nMCMrow; iMCMrow++) {
+          for (Int_t iMCMcol = 0; iMCMcol < nMCMcol; iMCMcol++) {
+            xpos   = (0.5 + iMCMcol) * xSize + 1.0 
+                   - fCwidth[iplan]/2.;
+            ypos   = (0.5 + iMCMrow) * ySize + 1.0 
+                   - fClengthRH[iplan][icham]/2. + fgkHspace/2.;
+            zpos   = -0.4;
+            if (ypos < (fClengthRH[iplan][icham]/2. - fgkHspace/2.)) {
+              par[0] = 0.0;
+              par[1] = 0.2/2.; // Thickness of the power lines
+              par[2] = fCwidth[iplan]/2.;
+              gMC->Gspos("UMCM",iCopy+iMCMrow*10+iMCMcol+20*nMCMrow,cTagV
+                               ,xpos,ypos,zpos,0,"ONLY");
+           }
+         }
+        }
+      }
+
+    }
+  }
+
+  delete parameter;
+
 }
 
 //_____________________________________________________________________________
@@ -760,7 +1397,7 @@ void AliTRDgeometryFull::SetOldGeometry()
                                     , { 127.5,   0.0,   0.0,   0.0, 127.5 }
                                     , { 134.5,   0.0,   0.0,   0.0, 134.5 }
                                      , { 134.5,   0.0,   0.0,   0.0, 134.5 } };
-
+                                                                               
   for (icham = 0; icham < kNcham; icham++) {
     for (iplan = 0; iplan < kNplan; iplan++) {
       fClengthPH[iplan][icham] = lengthPH[iplan][icham];
index 5eb30be9ba3d2bb99c2bc7dbf4a4329afaa98bfe..8a2ac5549befdf8128fbebefba8798dbe25e8f8d 100644 (file)
@@ -21,6 +21,8 @@ class AliTRDgeometryFull : public AliTRDgeometry {
   virtual ~AliTRDgeometryFull();
 
           void    CreateGeometry(Int_t *idtmed);
+          void    CreateFrame(Int_t *idtmed);
+          void    CreateServices(Int_t *idtmed);
           Int_t   IsVersion() const   { return 1; };
           void    Init();
 
@@ -37,7 +39,7 @@ class AliTRDgeometryFull : public AliTRDgeometry {
   Bool_t          fPHOShole;                  // Switch for the hole in front of the PHOS
   Bool_t          fRICHhole;                  // Switch for the hole in front of the RICH
 
-  ClassDef(AliTRDgeometryFull,2)              // TRD geometry without hole
+  ClassDef(AliTRDgeometryFull,3)              // TRD geometry without hole
 
 };
 
index 38937d300cf4326d83e341e4ba978474d7f9c8c3..5440a5bcf4ca947e7b362f9e2da6918724f043a6 100644 (file)
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
 
-/* $Id$ */
+/*
+$Log$
+Revision 1.9  2002/11/21 22:38:47  alibrary
+Removing AliMC and AliMCProcess
+
+Revision 1.8  2002/10/31 17:45:35  cblume
+New chamber geometry
+
+Revision 1.7  2002/02/11 14:21:16  cblume
+Update of the geometry. Get rid of MANY
+
+Revision 1.6  2001/05/11 07:56:12  hristov
+Consistent declarations needed on Alpha
+
+Revision 1.5  2001/02/14 18:22:26  cblume
+Change in the geometry of the padplane
+
+Revision 1.4  2000/11/01 14:53:21  cblume
+Merge with TRD-develop
+
+Revision 1.1.4.4  2000/10/15 23:40:01  cblume
+Remove AliTRDconst
+
+Revision 1.1.4.3  2000/10/06 16:49:46  cblume
+Made Getters const
+
+Revision 1.1.4.2  2000/10/04 16:34:58  cblume
+Replace include files by forward declarations
+
+Revision 1.1.4.1  2000/09/22 14:43:41  cblume
+Allow the pad/timebin-dimensions to be changed after initialization
+
+Revision 1.3  2000/10/02 21:28:19  fca
+Removal of useless dependecies via forward declarations
+
+Revision 1.2  2000/06/08 18:32:58  cblume
+Make code compliant to coding conventions
+
+Revision 1.1  2000/02/28 19:01:42  cblume
+Add new TRD classes
+
+*/
 
 ///////////////////////////////////////////////////////////////////////////////
 //                                                                           //
@@ -21,7 +62,8 @@
 //                                                                           //
 ///////////////////////////////////////////////////////////////////////////////
 
-#include <TVirtualMC.h>
+#include "TVirtualMC.h"
+
 #include "AliTRDgeometryHole.h"
 
 ClassImp(AliTRDgeometryHole)
index d419c1a3e81e935fb170c43d1398bc020a074a6b..0099ade25add518b431efc334db9d23a8028540e 100644 (file)
@@ -76,7 +76,7 @@ AliTRDmatrix::AliTRDmatrix(Int_t nRow, Int_t nCol, Int_t nTime
 }
 
 //_____________________________________________________________________________
-AliTRDmatrix::AliTRDmatrix(const AliTRDmatrix &m)
+AliTRDmatrix::AliTRDmatrix(const AliTRDmatrix &m):TObject(m)
 {
   //
   // AliTRDmatrix copy constructor
index 5ba8bc597b58409752a38969ac887a9fe9f77d3c..48eb5dc61b0ead2f7b56b27a95be5daa1ae6cc9f 100644 (file)
@@ -141,7 +141,7 @@ AliTRDparameter::AliTRDparameter(const Text_t *name, const Text_t *title)
 
 
 //_____________________________________________________________________________
-AliTRDparameter::AliTRDparameter(const AliTRDparameter &p)
+AliTRDparameter::AliTRDparameter(const AliTRDparameter &p):TNamed(p)
 {
   //
   // AliTRDparameter copy constructor
@@ -312,6 +312,14 @@ void AliTRDparameter::Init()
   SetColPadSize(4,0.77);
   SetColPadSize(5,0.80);
 
+  // New pad size? Needs to be checked!
+  //SetColPadSize(0,0.664);
+  //SetColPadSize(1,0.695);
+  //SetColPadSize(2,0.726);
+  //SetColPadSize(3,0.756);
+  //SetColPadSize(4,0.788);
+  //SetColPadSize(5,0.818);
+
   // The pad row (z-direction)
   SetNRowPad();
 
@@ -333,7 +341,6 @@ void AliTRDparameter::Init()
   fChipGain       = 12.4;
   fNoise          = 1000.;
   fADCoutRange    = 1023.;          // 10-bit ADC
-  //fADCinRange     = 1000.;          // 1V input range
   fADCinRange     = 2000.;          // 2V input range
   fADCthreshold   = 1;
   fADCbaseline    = 0;
@@ -373,11 +380,9 @@ void AliTRDparameter::Init()
   fTimeCoupling   = 0.4;
 
   // The tilting angle for the readout pads
-  //SetTiltingAngle(5.0);
-  SetTiltingAngle(0.0);
+  SetTiltingAngle(2.0);
 
   // The magnetic field strength in Tesla
-  //fField           = 0.2 * gAlice->Field()->Factor();
   fField           = 0.4;
 
   //
index cc34adbd7ab96fdb60710941476982c6a05f57b5..c50929ccbdaf762828336d52fe850df814e1527c 100644 (file)
@@ -87,7 +87,7 @@ AliTRDpid::AliTRDpid(const char* name, const char* title):TNamed(name,title)
 }
 
 //_____________________________________________________________________________
-AliTRDpid::AliTRDpid(const AliTRDpid &p)
+AliTRDpid::AliTRDpid(const AliTRDpid &p):TNamed(p)
 {
   //
   // AliTRDpid copy constructor
index 105a05e5a1626026715f725a90819743164ffbf1..61a2e7f494ed224176d79ce101385f4017ef5336 100644 (file)
@@ -93,7 +93,7 @@ AliTRDpidLQ::AliTRDpidLQ(const char* name, const char* title)
 }
 
 //_____________________________________________________________________________
-AliTRDpidLQ::AliTRDpidLQ(const AliTRDpidLQ &p)
+AliTRDpidLQ::AliTRDpidLQ(const AliTRDpidLQ &p):AliTRDpid(p)
 {
   //
   // AliTRDpidLQ copy constructor
index 20e4f3c7c3ab290a82da5120718e945b2ce84883..60ae048f136b4eb344cd2919b260c5f0eea19618 100644 (file)
@@ -57,7 +57,7 @@ AliTRDpoints::AliTRDpoints(Int_t nhitsE, Int_t nhitsT):AliPoints(nhitsE)
 }
         
 //_____________________________________________________________________________
-AliTRDpoints::AliTRDpoints(const AliTRDpoints &p)
+AliTRDpoints::AliTRDpoints(const AliTRDpoints &p):AliPoints(p)
 {
   //
   // Copy contructor
index f8cae6073f4d64a4925fe66c185c8ec48592a70e..9f7a99319ed65f3a8e9c4f53bec92d118c4b0c51 100644 (file)
@@ -109,7 +109,7 @@ void AliTRDrecPoint::AddDigit(Int_t digit)
 }
 
 //_____________________________________________________________________________
-void AliTRDrecPoint::SetLocalPosition(TVector3 &pos)
+void AliTRDrecPoint::SetLocalPosition(TVector3 & /*pos*/)
 {
   //
   // Sets the position of the point in the local coordinate system
@@ -143,7 +143,7 @@ void AliTRDrecPoint::SetLocalPosition(TVector3 &pos)
 }
 
 //_____________________________________________________________________________
-void AliTRDrecPoint::SetTrackingYZ(Float_t sigmaY, Float_t sigmaZ)
+void AliTRDrecPoint::SetTrackingYZ(Float_t /*sigmaY*/, Float_t /*sigmaZ*/)
 {
  //
  // Sets the position of the point in the local coordinate system
index 18fb5a25f34a363e8efeca6c3162ca375c4d711f..9e096f9bfd5e77845f5d5e09f4c7271b14adbc0b 100644 (file)
@@ -21,9 +21,9 @@ class AliTRDrecPoint : public AliRecPoint {
   AliTRDrecPoint(const char * opt);
   virtual ~AliTRDrecPoint();
 
-  virtual void    Print(Option_t* opt) const {};
+  virtual void    Print(Option_t* ) const {};
   virtual void    AddDigit(Int_t digit);
-  virtual void    AddDigit(AliDigitNew &digit) {};
+  virtual void    AddDigit(AliDigitNew) {};
 
   virtual void    SetEnergy(Float_t amp)          { fAmp      = amp; };
   virtual void    SetDetector(Int_t det)          { fDetector = det; };
index 1181e02c0e9cee7c226aee44ec1b5176a4fdf5fe..fbe9ea0096446c1d2e0fd24d15515e91177dc6b9 100644 (file)
@@ -59,6 +59,7 @@ AliTRDsegmentArray::AliTRDsegmentArray(Text_t *classname, Int_t n)
 
 //_____________________________________________________________________________
 AliTRDsegmentArray::AliTRDsegmentArray(AliTRDsegmentArray &a)
+:AliTRDsegmentArrayBase(a)
 {
   //
   // AliTRDsegmentArray copy constructor
index 553bd247e3078b2414e2fafc12a52c25f49fcc8b..a14ff9483abeb82c9cfbfd8f146220ae3f984645 100644 (file)
@@ -77,6 +77,7 @@ AliTRDsegmentArrayBase::AliTRDsegmentArrayBase(Text_t *classname, Int_t n)
 
 //_____________________________________________________________________________
 AliTRDsegmentArrayBase::AliTRDsegmentArrayBase(const AliTRDsegmentArrayBase &a)
+:TNamed(a)
 {
   //
   // AliTRDsegmentArrayBase copy constructor
index 4a1c2afca6c21754af03d1f57252b788d4e1fab4..0bdd970ed501c777dd08949bffa7e5bc73de1f03 100644 (file)
@@ -90,7 +90,7 @@ AliTRDsim::AliTRDsim(AliModule *mod, Int_t foil, Int_t gap)
 }
 
 //_____________________________________________________________________________
-AliTRDsim::AliTRDsim(const AliTRDsim &s)
+AliTRDsim::AliTRDsim(const AliTRDsim &s):TObject(s)
 {
   //
   // AliTRDsim copy constructor
index 052ed7f82433bacb934ac9ddf9289ec13eb46dc7..cf66d73325e7745d373a261e7cf92c0c56333624 100644 (file)
@@ -41,7 +41,7 @@ AliTRDsimple::AliTRDsimple():TObject()
 }                                                                               
  
 //_____________________________________________________________________________
-AliTRDsimple::AliTRDsimple(const AliTRDsimple &s)
+AliTRDsimple::AliTRDsimple(const AliTRDsimple &s):TObject(s)
 {
   //
   // AliTRDsimple copy constructor
index e0681ae66292e2b21ab12e5d36af5aec628de4e9..1db2cd9a6dad9814028623c69439c99934d0447b 100644 (file)
@@ -47,7 +47,7 @@ AliTRDsimpleGen::AliTRDsimpleGen():TObject()
 }                                                                               
  
 //_____________________________________________________________________________
-AliTRDsimpleGen::AliTRDsimpleGen(const AliTRDsimpleGen &g)
+AliTRDsimpleGen::AliTRDsimpleGen(const AliTRDsimpleGen &g):TObject(g)
 {
   //
   // AliTRDsimpleGen copy constructor
index 11854d629d819872e20f8a6a7751721a1a7dd45a..ffd45b47cf00b9d7aefe19ddc84641c0ed9005be 100644 (file)
@@ -94,7 +94,7 @@ AliTRDsimpleMC::AliTRDsimpleMC(const char *name, const char *title)
 }                                                                               
  
 //_____________________________________________________________________________
-AliTRDsimpleMC::AliTRDsimpleMC(const AliTRDsimpleMC &m)
+AliTRDsimpleMC::AliTRDsimpleMC(const AliTRDsimpleMC &m):TVirtualMC(m)
 {
   //
   // AliTRDsimpleMC copy constructor
@@ -363,7 +363,7 @@ const char *AliTRDsimpleMC::CurrentVolName() const
 }
 
 //_____________________________________________________________________________
-Int_t AliTRDsimpleMC::CurrentVolOffID(Int_t off, Int_t &copyNo) const
+Int_t AliTRDsimpleMC::CurrentVolOffID(Int_t , Int_t &copyNo) const
 {
   //
   // Check for the current volume
index 3e9ec6788bca202a8e01990181a87ecd03b21782..e75bbc3e35f363baa7dcd171ef06389e91037a67 100644 (file)
@@ -41,95 +41,95 @@ class AliTRDsimpleMC : public TVirtualMC {
   //
 
   // Functions from GCONS 
-    virtual void  Gfmate(Int_t imat, char *name, Float_t &a, Float_t &z,  
-                        Float_t &dens, Float_t &radl, Float_t &absl,
-                        Float_t* ubuf, Int_t& nbuf)  {}
-    virtual void  Gfmate(Int_t imat, char *name, Double_t &a, Double_t &z,  
-                        Double_t &dens, Double_t &radl, Double_t &absl,
-                        Double_t* ubuf, Int_t& nbuf) {}
+    virtual void  Gfmate(Int_t , char* , Float_t& , Float_t& ,  
+                        Float_t& , Float_t& , Float_t& ,
+                        Float_t* , Int_t& )  {}
+    virtual void  Gfmate(Int_t , char* , Double_t& , Double_t& ,  
+                        Double_t& , Double_t& , Double_t& ,
+                        Double_t* , Int_t& ) {}
 
   // Detector composition
-    virtual void  Material(Int_t& kmat, const char* name, Double_t a
-                     Double_t z, Double_t dens, Double_t radl, Double_t absl,
-                     Float_t* buf, Int_t nwbuf) {}
-    virtual void  Material(Int_t& kmat, const char* name, Double_t a
-                     Double_t z, Double_t dens, Double_t radl, Double_t absl,
-                     Double_t* buf, Int_t nwbuf) {}
-    virtual void  Mixture(Int_t& kmat, const char *name, Float_t *a
-                     Float_t *z, Double_t dens, Int_t nlmat, Float_t *wmat) {}
-    virtual void  Mixture(Int_t& kmat, const char *name, Double_t *a
-                     Double_t *z, Double_t dens, Int_t nlmat, Double_t *wmat) {}
-    virtual void  Medium(Int_t& kmed, const char *name, Int_t nmat
-                     Int_t isvol, Int_t ifield, Double_t fieldm, Double_t tmaxfd
-                     Double_t stemax, Double_t deemax, Double_t epsil
-                    Double_t stmin, Float_t* ubuf, Int_t nbuf) {}
-    virtual void  Medium(Int_t& kmed, const char *name, Int_t nmat
-                     Int_t isvol, Int_t ifield, Double_t fieldm, Double_t tmaxfd
-                     Double_t stemax, Double_t deemax, Double_t epsil
-                    Double_t stmin, Double_t* ubuf, Int_t nbuf) {}
-    virtual void  Matrix(Int_t& krot, Double_t thetaX, Double_t phiX
-                     Double_t thetaY, Double_t phiY, Double_t thetaZ
-                    Double_t phiZ) {}
-    virtual void  Gstpar(Int_t itmed, const char *param, Double_t parval) {} 
+    virtual void  Material(Int_t& , const char* , Double_t 
+                     Double_t , Double_t , Double_t , Double_t ,
+                     Float_t* , Int_t ) {}
+    virtual void  Material(Int_t& , const char* , Double_t 
+                     Double_t , Double_t , Double_t , Double_t ,
+                     Double_t* , Int_t ) {}
+    virtual void  Mixture(Int_t& , const char* , Float_t* 
+                     Float_t *, Double_t , Int_t , Float_t* ) {}
+    virtual void  Mixture(Int_t& , const char* , Double_t *
+                     Double_t *, Double_t , Int_t , Double_t* ) {}
+    virtual void  Medium(Int_t& , const char* , Int_t 
+                     Int_t , Int_t , Double_t , Double_t 
+                     Double_t , Double_t , Double_t 
+                    Double_t , Float_t* , Int_t ) {}
+    virtual void  Medium(Int_t& , const char* , Int_t 
+                     Int_t , Int_t , Double_t , Double_t 
+                     Double_t , Double_t , Double_t 
+                    Double_t , Double_t* , Int_t ) {}
+    virtual void  Matrix(Int_t& , Double_t , Double_t 
+                     Double_t , Double_t , Double_t 
+                    Double_t ) {}
+    virtual void  Gstpar(Int_t , const char* , Double_t ) {} 
 
   // Functions from GGEOM 
-    virtual Int_t  Gsvolu(const char *name, const char *shape, Int_t nmed,  
-                          Float_t *upar, Int_t np)  { return 0; }
-    virtual Int_t  Gsvolu(const char *name, const char *shape, Int_t nmed,  
-                          Double_t *upar, Int_t np) { return 0; } 
-    virtual void  Gsdvn(const char *name, const char *mother, Int_t ndiv
-                         Int_t iaxis) {} 
-    virtual void  Gsdvn2(const char *name, const char *mother, Int_t ndiv
-                         Int_t iaxis, Double_t c0i, Int_t numed) {} 
-    virtual void  Gsdvt(const char *name, const char *mother, Double_t step
-                         Int_t iaxis, Int_t numed, Int_t ndvmx) {} 
-    virtual void  Gsdvt2(const char *name, const char *mother, Double_t step
-                         Int_t iaxis, Double_t c0, Int_t numed, Int_t ndvmx) {} 
-    virtual void  Gsord(const char *name, Int_t iax) {} 
-    virtual void  Gspos(const char *name, Int_t nr, const char *mother,  
-                         Double_t x, Double_t y, Double_t z, Int_t irot
-                         const char *konly="ONLY") {} 
-    virtual void  Gsposp(const char *name, Int_t nr, const char *mother,  
-                         Double_t x, Double_t y, Double_t z, Int_t irot,
-                         const char *konly, Float_t *upar, Int_t np) {}
-    virtual void  Gsposp(const char *name, Int_t nr, const char *mother,  
-                         Double_t x, Double_t y, Double_t z, Int_t irot,
-                         const char *konly, Double_t *upar, Int_t np) {}
-    virtual void  Gsbool(const char* onlyVolName, const char* manyVolName) {}
+    virtual Int_t  Gsvolu(const char* , const char* , Int_t ,  
+                          Float_t* , Int_t )  { return 0; }
+    virtual Int_t  Gsvolu(const char* , const char* , Int_t ,  
+                          Double_t* , Int_t) { return 0; } 
+    virtual void  Gsdvn(const char* , const char* , Int_t 
+                         Int_t ) {} 
+    virtual void  Gsdvn2(const char* , const char* , Int_t 
+                         Int_t , Double_t , Int_t ) {} 
+    virtual void  Gsdvt(const char* , const char* , Double_t 
+                         Int_t , Int_t , Int_t ) {} 
+    virtual void  Gsdvt2(const char* , const char* , Double_t 
+                         Int_t , Double_t , Int_t , Int_t ) {} 
+    virtual void  Gsord(const char* , Int_t ) {} 
+    virtual void  Gspos(const char* , Int_t , const char* ,  
+                         Double_t , Double_t , Double_t , Int_t 
+                         const char) {} 
+    virtual void  Gsposp(const char* , Int_t , const char* ,  
+                         Double_t, Double_t, Double_t, Int_t ,
+                         const char* , Float_t* , Int_t ) {}
+    virtual void  Gsposp(const char* , Int_t , const char* ,  
+                         Double_t , Double_t , Double_t , Int_t ,
+                         const char* , Double_t* , Int_t ) {}
+    virtual void  Gsbool(const char* , const char* ) {}
 
-    virtual void  SetCerenkov(Int_t itmed, Int_t npckov, Float_t *ppckov,
-                               Float_t *absco, Float_t *effic, Float_t *rindex) {}
-    virtual void  SetCerenkov(Int_t itmed, Int_t npckov, Double_t *ppckov,
-                               Double_t *absco, Double_t *effic, Double_t *rindex) {}
+    virtual void  SetCerenkov(Int_t , Int_t , Float_t* ,
+                               Float_t* , Float_t* , Float_t* ) {}
+    virtual void  SetCerenkov(Int_t , Int_t , Double_t* ,
+                               Double_t* , Double_t* , Double_t* ) {}
 
   // Functions for drawing
-    virtual void  DrawOneSpec(const char* name) {}
-    virtual void  Gsatt(const char* name, const char* att, Int_t val) {}
-    virtual void  Gdraw(const char*,Double_t theta = 30, Double_t phi = 30,
-                       Double_t psi = 0, Double_t u0 = 10, Double_t v0 = 10,
-                       Double_t ul = 0.01, Double_t vl = 0.01) {}
+    virtual void  DrawOneSpec(const char* ) {}
+    virtual void  Gsatt(const char* , const char* , Int_t ) {}
+    virtual void  Gdraw(const char* , Double_t , Double_t ,
+                       Double_t , Double_t , Double_t ,
+                       Double_t , Double_t ) {}
 
   // Euclid
-  virtual void          WriteEuclid(const char *a, const char *b, Int_t c, Int_t d) {}
+  virtual void          WriteEuclid(const char* , const char* , Int_t , Int_t ) {}
                               
   // Get methods
     virtual Int_t VolId(const Text_t* volName) const;
-    virtual const char* VolName(Int_t id) const { return ""; }
+    virtual const char* VolName(Int_t ) const { return ""; }
     virtual Int_t NofVolumes() const { return 0; }
-    virtual Int_t VolId2Mate(Int_t id) const { return 0; }
+    virtual Int_t VolId2Mate(Int_t ) const { return 0; }
 
   //
   // Methods for physics management
   //
  
   // Set methods
-    virtual void     SetCut(const char* cutName, Double_t cutValue) {}
-    virtual void     SetProcess(const char* flagName, Int_t flagValue) {}
+    virtual void     SetCut(const char* , Double_t ) {}
+    virtual void     SetProcess(const char* , Int_t ) {}
     virtual Double_t Xsec(char*, Double_t, Int_t, Int_t) { return 0.; } 
  
   // Particle table usage         
-    virtual Int_t   IdFromPDG(Int_t id) const  { return 0; }  
-    virtual Int_t   PDGFromId(Int_t pdg) const { return 0; }  
+    virtual Int_t   IdFromPDG(Int_t ) const { return 0; }  
+    virtual Int_t   PDGFromId(Int_t ) const { return 0; }  
     virtual void    DefineParticles() {}      
   
   //
@@ -142,8 +142,8 @@ class AliTRDsimpleMC : public TVirtualMC {
 
   // Set methods
   virtual void          SetMaxStep(Double_t step)                                         { fMaxStep = step; };
-  virtual void          SetMaxNStep(Int_t n)                                              { };
-  virtual void          SetUserDecay(Int_t d)                                             { };  
+  virtual void          SetMaxNStep(Int_t )                                              { };
+  virtual void          SetUserDecay(Int_t )                                             { };  
 
   virtual void          NewTrack(Int_t iTrack, Int_t pdg, Double_t px, Double_t py, Double_t pz);
 
@@ -151,15 +151,15 @@ class AliTRDsimpleMC : public TVirtualMC {
   virtual Int_t         CurrentVolID(Int_t& copyNo) const;
   virtual Int_t         CurrentVolOffID(Int_t off, Int_t& copyNo) const;
   virtual const char*   CurrentVolName() const;
-  virtual const char*   CurrentVolOffName(Int_t off) const                                { return ""; };
-  virtual Int_t         CurrentMaterial(Float_t &a, Float_t &z
-                                        Float_t &dens, Float_t &radl
-                                       Float_t &absl) const                              { return 0;  };  
+  virtual const char*   CurrentVolOffName(Int_t ) const                                { return ""; };
+  virtual Int_t         CurrentMaterial(Float_t& , Float_t& 
+                                        Float_t& , Float_t& 
+                                       Float_t& ) const                               { return 0;  };  
   virtual Int_t         CurrentEvent() const                                              { return 0;  }; 
-  virtual void          Gmtod(Float_t* xm, Float_t* xd, Int_t iflag)   {}
-  virtual void          Gmtod(Double_t* xm, Double_t* xd, Int_t iflag) {}
-  virtual void          Gdtom(Float_t* xd, Float_t* xm, Int_t iflag)   {}
-  virtual void          Gdtom(Double_t* xd, Double_t* xm, Int_t iflag) {}
+  virtual void          Gmtod(Float_t* , Float_t* , Int_t )   {}
+  virtual void          Gmtod(Double_t* , Double_t* , Int_t ) {}
+  virtual void          Gdtom(Float_t* , Float_t* , Int_t )   {}
+  virtual void          Gdtom(Double_t* , Double_t* , Int_t ) {}
   virtual Double_t      MaxStep() const                                                   { return fMaxStep; };
   virtual Int_t         GetNStep() const                                                  { return fNStep;   };
   virtual Int_t         GetMaxNStep() const                                               { return 0;  };
@@ -193,11 +193,11 @@ class AliTRDsimpleMC : public TVirtualMC {
 
   // Secondaries
   virtual Int_t         NSecondaries() const                                              { return 0; };
-  virtual void          GetSecondary(Int_t isec, Int_t& particleId
-                                     TLorentzVector& position
-                                     TLorentzVector& momentum)                            { };
-  virtual TMCProcess  ProdProcess(Int_t isec) const                                     { return kPNoProcess; }; 
-  virtual Int_t         StepProcesses(TArrayI &proc) const                                { return 0; };
+  virtual void          GetSecondary(Int_t , Int_t& 
+                                     TLorentzVector& , 
+                                     TLorentzVector& )                                    { };
+  virtual TMCProcess  ProdProcess(Int_t ) const                                           { return kPNoProcess; }; 
+  virtual Int_t         StepProcesses(TArrayI& ) const                                    { return 0; };
 
   //
   // Other (then geometry/step/run management) methods
@@ -223,11 +223,11 @@ class AliTRDsimpleMC : public TVirtualMC {
   virtual void          FinishGeometry()                                                  { };
   virtual void          BuildPhysics()                                                    { };
   virtual void          ProcessEvent();
-  virtual void          ProcessRun(Int_t nevent)                                          { };
+  virtual void          ProcessRun(Int_t )                                                { };
   //virtual TMCGeomType   GetMCGeomType() const                                             { return kGeant3; }
 
   // External Decayer
-  virtual void          SetExternalDecayer(AliDecayer* decayer)                           { };
+  virtual void          SetExternalDecayer(AliDecayer* )                                  { };
   virtual AliDecayer   *Decayer() const                                                   { return 0; };
 
  protected:
index 60b2e33bd3274b3ab381ac532b8dfac4b453776a..3efe196aa324700ec2d4dfca0b172c362ffce017 100644 (file)
@@ -15,6 +15,9 @@
 
 /*
 $Log$
+Revision 1.23  2003/07/22 15:56:14  hristov
+Implementing ESD functionality in the NewIO (Yu.Belikov)
+
 Revision 1.20.2.1  2003/07/14 09:19:33  hristov
 TOF included in the combined PID (Yu.Belikov)
 
@@ -128,7 +131,7 @@ AliTRDtrack::AliTRDtrack(const AliTRDcluster *c, UInt_t index,
   fdQdl[0] = q;
   
   // initialisation [SR, GSI 18.02.2003] (i startd for 1)
-  for(Int_t i=1; i<kMAX_CLUSTERS_PER_TRACK; i++) {
+  for(UInt_t i=1; i<kMAX_CLUSTERS_PER_TRACK; i++) {
     fdQdl[i] = 0;
     fIndex[i] = 0;
   }
@@ -169,7 +172,7 @@ AliTRDtrack::AliTRDtrack(const AliTRDtrack& t) : AliKalmanTrack(t) {
   }
 
   // initialisation (i starts from n) [SR, GSI, 18.02.2003]
-  for(Int_t i=n; i<kMAX_CLUSTERS_PER_TRACK; i++) {
+  for(UInt_t i=n; i<kMAX_CLUSTERS_PER_TRACK; i++) {
     fdQdl[i] = 0;
     fIndex[i] = 0;
   }
@@ -225,7 +228,7 @@ AliTRDtrack::AliTRDtrack(const AliKalmanTrack& t, Double_t alpha)
   fCcy=c[10];   fCcz=c[11];   fCce=c42;   fCct=c[13]; fCcc=c[14];  
 
   // Initialization [SR, GSI, 18.02.2003]
-  for(Int_t i=0; i<kMAX_CLUSTERS_PER_TRACK; i++) {
+  for(UInt_t i=0; i<kMAX_CLUSTERS_PER_TRACK; i++) {
     fdQdl[i] = 0;
     fIndex[i] = 0;
   }
@@ -281,7 +284,7 @@ AliTRDtrack::AliTRDtrack(const AliESDtrack& t)
   fCcy=c[10];   fCcz=c[11];   fCce=c42;   fCct=c[13]; fCcc=c[14];  
 
   // Initialization [SR, GSI, 18.02.2003]
-  for(Int_t i=0; i<kMAX_CLUSTERS_PER_TRACK; i++) {
+  for(UInt_t i=0; i<kMAX_CLUSTERS_PER_TRACK; i++) {
     fdQdl[i] = 0;
     fIndex[i] = 0;
   }
index 9577e05d7674e208d9762ff156d1e319e1ad22d0..696e687ba173964d5375e41c14341a4ecb3d41cc 100644 (file)
@@ -86,9 +86,9 @@ Bool_t AliTRDtrackHits::Next()
   fCurrentHit->fStackIndex++;
 
   AliTrackHitsParamV2 *param =  (AliTrackHitsParamV2 *)fArray->At(fCurrentHit->fParamIndex);
-  if (fCurrentHit->fStackIndex>=((UInt_t) param->fNHits)){
+  if (fCurrentHit->fStackIndex>= param->fNHits){
     fCurrentHit->fParamIndex++;
-    if (fCurrentHit->fParamIndex>=((UInt_t) fArray->GetEntriesFast())){
+    if (fCurrentHit->fParamIndex>= fArray->GetEntriesFast()){
       fCurrentHit->fStatus=kFALSE;
       return kFALSE;
     }
index bf239bb7e81b83f6509f09367c5b968770c1b6ee..1d58855db510b3cd46173340c42f135bcad03253 100644 (file)
@@ -15,6 +15,9 @@
                                                       
 /*
 $Log$
+Revision 1.29  2003/07/22 15:56:14  hristov
+Implementing ESD functionality in the NewIO (Yu.Belikov)
+
 Revision 1.27.2.2  2003/07/14 09:19:33  hristov
 TOF included in the combined PID (Yu.Belikov)
 
@@ -2076,7 +2079,7 @@ void AliTRDtracker::UseClusters(const AliKalmanTrack* t, Int_t from) const {
 
 
 //_____________________________________________________________________
-Double_t AliTRDtracker::ExpectedSigmaY2(Double_t r, Double_t tgl, Double_t pt)
+Double_t AliTRDtracker::ExpectedSigmaY2(Double_t , Double_t , Double_t )
 {
   // Parametrised "expected" error of the cluster reconstruction in Y 
 
@@ -2085,7 +2088,7 @@ Double_t AliTRDtracker::ExpectedSigmaY2(Double_t r, Double_t tgl, Double_t pt)
 }
 
 //_____________________________________________________________________
-Double_t AliTRDtracker::ExpectedSigmaZ2(Double_t r, Double_t tgl)
+Double_t AliTRDtracker::ExpectedSigmaZ2(Double_t , Double_t )
 {
   // Parametrised "expected" error of the cluster reconstruction in Z 
 
index 7a8e18748d894911c2f1d408872570ad0ae22dac..c25d34eda147da6521d94f13f493147ba1161f8c 100644 (file)
@@ -38,7 +38,7 @@ class AliTRDtracker : public AliTracker {
   Int_t         Clusters2Tracks(AliESD* event);
   Int_t         PropagateBack(const TFile *in, TFile *out);
   Int_t         PropagateBack(AliESD* event);
-  Int_t         RefitInward(AliESD* event) {return 0;}
+  Int_t         RefitInward(AliESD* /*event*/) {return 0;}
 
   Int_t         LoadClusters(TTree *cTree);
   void          UnloadClusters(){UnloadEvent();}
index 46b7246b9532646607150bee6d68ef8b6bdaff90..6d2139e003bbf2eeb74867bc3c291d6f240cd782 100644 (file)
@@ -87,7 +87,7 @@ AliTRDv1::AliTRDv1(const char *name, const char *title)
 }
 
 //_____________________________________________________________________________
-AliTRDv1::AliTRDv1(const AliTRDv1 &trd)
+AliTRDv1::AliTRDv1(const AliTRDv1 &trd):AliTRD(trd)
 {
   //
   // Copy constructor
index fdaf8254eefc8e68f2a099e2e6a9a0e98a2bcbd3..586c5eb46c158c3dcf52293bf6abcb838066862e 100644 (file)
@@ -72,7 +72,7 @@ AliTRDv2::AliTRDv2(const char *name, const char *title)
 }
 
 //_____________________________________________________________________________
-AliTRDv2::AliTRDv2(const AliTRDv2 &trd)
+AliTRDv2::AliTRDv2(const AliTRDv2 &trd):AliTRDv1(trd)
 {
   //
   // Copy constructor
@@ -110,6 +110,8 @@ void AliTRDv2::Copy(TObject &trd)
   // Copy function
   //
 
+  AliTRDv1::Copy(trd); 
+
 }
 
 //_____________________________________________________________________________