Remove compiler warnings
authorcblume <cblume@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 24 Mar 2005 12:13:54 +0000 (12:13 +0000)
committercblume <cblume@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 24 Mar 2005 12:13:54 +0000 (12:13 +0000)
57 files changed:
TRD/AliTRD.cxx
TRD/AliTRD.h
TRD/AliTRDReconstructor.h
TRD/AliTRDarrayF.cxx
TRD/AliTRDarrayF.h
TRD/AliTRDarrayI.cxx
TRD/AliTRDarrayI.h
TRD/AliTRDclusterizer.cxx
TRD/AliTRDclusterizer.h
TRD/AliTRDclusterizerMI.h
TRD/AliTRDclusterizerV1.cxx
TRD/AliTRDclusterizerV1.h
TRD/AliTRDdataArray.cxx
TRD/AliTRDdataArray.h
TRD/AliTRDdataArrayF.cxx
TRD/AliTRDdataArrayF.h
TRD/AliTRDdataArrayI.cxx
TRD/AliTRDdataArrayI.h
TRD/AliTRDdigitizer.cxx
TRD/AliTRDdigitizer.h
TRD/AliTRDdigitsManager.cxx
TRD/AliTRDdigitsManager.h
TRD/AliTRDgeometry.cxx
TRD/AliTRDmatrix.cxx
TRD/AliTRDmatrix.h
TRD/AliTRDpadPlane.cxx [new file with mode: 0644]
TRD/AliTRDpadPlane.h [new file with mode: 0644]
TRD/AliTRDparameter.cxx
TRD/AliTRDparameter.h
TRD/AliTRDpid.cxx
TRD/AliTRDpid.h
TRD/AliTRDpidLQ.cxx
TRD/AliTRDpidLQ.h
TRD/AliTRDpixel.cxx
TRD/AliTRDpixel.h
TRD/AliTRDpoints.cxx
TRD/AliTRDpoints.h
TRD/AliTRDrawData.cxx
TRD/AliTRDrawData.h
TRD/AliTRDsegmentArray.cxx
TRD/AliTRDsegmentArray.h
TRD/AliTRDsegmentArrayBase.cxx
TRD/AliTRDsegmentArrayBase.h
TRD/AliTRDsegmentID.h
TRD/AliTRDsim.cxx
TRD/AliTRDsim.h
TRD/AliTRDsimple.cxx
TRD/AliTRDsimple.h
TRD/AliTRDsimpleGen.cxx
TRD/AliTRDsimpleGen.h
TRD/AliTRDsimpleMC.cxx
TRD/AliTRDsimpleMC.h
TRD/AliTRDtrack.h
TRD/AliTRDv1.cxx
TRD/AliTRDv1.h
TRD/AliTRDv2.cxx
TRD/AliTRDv2.h

index 010580e..6402c73 100644 (file)
@@ -425,7 +425,7 @@ void AliTRD::BuildGeometry()
 }
  
 //_____________________________________________________________________________
-void AliTRD::Copy(TObject &trd)
+void AliTRD::Copy(TObject &trd) const
 {
   //
   // Copy function
@@ -694,7 +694,7 @@ void AliTRD::CreateMaterials()
 }
 
 //_____________________________________________________________________________
-void AliTRD::DrawModule() const
+void AliTRD::DrawModule()
 {
   //
   // Draw a shaded view of the Transition Radiation Detector version 0
@@ -753,7 +753,7 @@ void AliTRD::DrawModule() const
 }
 
 //_____________________________________________________________________________
-Int_t AliTRD::DistancetoPrimitive(Int_t , Int_t ) const
+Int_t AliTRD::DistancetoPrimitive(Int_t , Int_t )
 {
   //
   // Distance between the mouse and the TRD detector on the screen
index 64abc4b..e535a39 100644 (file)
@@ -35,13 +35,14 @@ class AliTRD : public AliDetector {
 
           AliTRD    &operator=(const AliTRD &trd);
 
+  virtual void       AddHit(Int_t, Int_t*, Float_t*) { }; 
   virtual void       AddHit(Int_t track, Int_t det, Float_t *hits, Int_t q, Bool_t inDrift); 
   virtual void       BuildGeometry();
-  virtual void       Copy(TObject &trd);
+  virtual void       Copy(TObject &trd) const;
   virtual void       CreateGeometry();
   virtual void       CreateMaterials();
-  virtual void       DrawModule() const;
-  Int_t              DistancetoPrimitive(Int_t px, Int_t py) const;
+  virtual void       DrawModule();
+  virtual Int_t      DistancetoPrimitive(Int_t px, Int_t py);
   virtual void       LoadPoints(Int_t track);    
   virtual void       Init();
   virtual Int_t      IsVersion() const = 0;
index 5ee0c51..e40a1b2 100644 (file)
 
 class AliTRDparameter;
 
-
 class AliTRDReconstructor: public AliReconstructor {
 public:
   AliTRDReconstructor(): AliReconstructor() {};
   virtual ~AliTRDReconstructor() {};
 
+  virtual void         Reconstruct(AliRunLoader*, AliRawReader*) const { };
+  virtual void         Reconstruct(AliRawReader*, TTree*) const { };
+  virtual void         Reconstruct(TTree*, TTree*) const { };
   virtual void         Reconstruct(AliRunLoader* runLoader) const;
   virtual AliTracker*  CreateTracker(AliRunLoader* runLoader) const;
+  virtual void         FillESD(AliRunLoader*, AliRawReader*, AliESD*) const { };
+  virtual void         FillESD(AliRawReader*, TTree*, AliESD*) const { };
+  virtual void         FillESD(TTree*, TTree*, AliESD*) const { };
   virtual void         FillESD(AliRunLoader* runLoader, AliESD* esd) const;
 
 private:
index 881a4ba..554ef5a 100644 (file)
@@ -49,7 +49,7 @@ AliTRDarrayF::~AliTRDarrayF()
 }
 
 //_____________________________________________________________________________
-void AliTRDarrayF::Copy(TObject &a)
+void AliTRDarrayF::Copy(TObject &a) const
 {
   //
   // Copy function
index 1c9bb4a..f7d8eae 100644 (file)
@@ -21,7 +21,7 @@ public:
 
   AliTRDarrayF();
   virtual ~AliTRDarrayF();
-  void Copy(TObject &a);
+  void Copy(TObject &a) const;
   void Expand(Int_t n);  
 
   ClassDef(AliTRDarrayF,1)  // An array of floats
index aed8018..1e1936d 100644 (file)
@@ -49,7 +49,7 @@ AliTRDarrayI::~AliTRDarrayI()
 }
 
 //_____________________________________________________________________________
-void AliTRDarrayI::Copy(TObject &a)
+void AliTRDarrayI::Copy(TObject &a) const
 {
   //
   // Copy function
index 6558b17..c6fef3e 100644 (file)
@@ -21,7 +21,7 @@ public:
 
   AliTRDarrayI();
   virtual ~AliTRDarrayI();
-  void Copy(TObject &a);
+  void Copy(TObject &a) const;
   void Expand(Int_t n);  
 
   ClassDef(AliTRDarrayI,1)  // An array of integers
index f47a689..25dfa90 100644 (file)
@@ -103,7 +103,7 @@ AliTRDclusterizer &AliTRDclusterizer::operator=(const AliTRDclusterizer &c)
 }
 
 //_____________________________________________________________________________
-void AliTRDclusterizer::Copy(TObject &c)
+void AliTRDclusterizer::Copy(TObject &c) const
 {
   //
   // Copy function
index 7fd3183..9c3f559 100644 (file)
@@ -28,7 +28,7 @@ class AliTRDclusterizer : public TNamed {
   virtual ~AliTRDclusterizer();
   AliTRDclusterizer &operator=(const AliTRDclusterizer &c);
 
-  virtual void    Copy(TObject &c);
+  virtual void    Copy(TObject &c) const;
   virtual Bool_t  Open(const Char_t *name, Int_t nEvent = 0);
   
   virtual Bool_t  OpenInput(Int_t nEvent = 0);
index 6f7e3e6..7f0a40d 100644 (file)
@@ -23,6 +23,7 @@ class AliTRDclusterizerMI : public AliTRDclusterizerV1 {
   virtual ~AliTRDclusterizerMI();
   virtual Bool_t   MakeClusters(); 
   void MakeCluster(Float_t * padSignal, Float_t * pos, Float_t &sigma, Float_t & relpad);
+  virtual void AddCluster(Float_t*, int, float, Int_t*, Float_t*, int) {};
   AliTRDclusterMI *  AddCluster();
   void SetCluster(AliTRDclusterMI * cl, Float_t *pos, Int_t det, Float_t amp
                  , Int_t *tracks, Float_t *sig, Int_t iType, Float_t sigmay,Float_t relpos);
index 10ce516..39990a4 100644 (file)
@@ -103,7 +103,7 @@ AliTRDclusterizerV1 &AliTRDclusterizerV1::operator=(const AliTRDclusterizerV1 &c
 }
 
 //_____________________________________________________________________________
-void AliTRDclusterizerV1::Copy(TObject &c)
+void AliTRDclusterizerV1::Copy(TObject &c) const
 {
   //
   // Copy function
index f4f5cca..37aeeaa 100644 (file)
@@ -24,7 +24,7 @@ class AliTRDclusterizerV1 : public AliTRDclusterizer {
   virtual ~AliTRDclusterizerV1();
   AliTRDclusterizerV1 &operator=(const AliTRDclusterizerV1 &c);
 
-  virtual void     Copy(TObject &c);
+  virtual void     Copy(TObject &c) const;
   virtual Bool_t   MakeClusters();
   virtual Bool_t   ReadDigits();
 
index 5e045f0..9f1fedf 100644 (file)
@@ -102,7 +102,7 @@ AliTRDdataArray &AliTRDdataArray::operator=(const AliTRDdataArray &d)
 }
 
 //_____________________________________________________________________________
-void AliTRDdataArray::Copy(TObject &d)
+void AliTRDdataArray::Copy(TObject &d) const
 {
   //
   // Copy function
index b47990f..d583364 100644 (file)
@@ -25,7 +25,7 @@ class AliTRDdataArray : public AliTRDsegmentID {
   virtual ~AliTRDdataArray();
   AliTRDdataArray &operator=(const AliTRDdataArray &d);
 
-  virtual void   Copy(TObject &d);
+  virtual void   Copy(TObject &d) const;
   virtual void   Allocate(Int_t nrow, Int_t ncol,Int_t ntime);
   virtual void   Reset();
 
index 4b9183f..d5f365b 100644 (file)
@@ -94,7 +94,7 @@ void AliTRDdataArrayF::Allocate(Int_t nrow, Int_t ncol, Int_t ntime)
 }
 
 //_____________________________________________________________________________
-void AliTRDdataArrayF::Copy(TObject &a)
+void AliTRDdataArrayF::Copy(TObject &a) const
 {
   //
   // Copy function
index 6ccbabc..2a8e7f2 100644 (file)
@@ -31,7 +31,7 @@ class AliTRDdataArrayF : public AliTRDdataArray {
   AliTRDdataArrayF &operator=(const AliTRDdataArrayF &a);
 
   virtual void    Allocate(Int_t nrow, Int_t ncol,Int_t ntime);
-  virtual void    Copy(TObject &a);
+  virtual void    Copy(TObject &a) const;
   virtual void    Compress(Int_t bufferType, Float_t threshold);
   virtual void    Compress(Int_t bufferType); 
   virtual void    Expand();
index 8cfcd32..d930361 100644 (file)
@@ -93,7 +93,7 @@ void AliTRDdataArrayI::Allocate(Int_t nrow, Int_t ncol, Int_t ntime)
 }
 
 //_____________________________________________________________________________
-void AliTRDdataArrayI::Copy(TObject &a)
+void AliTRDdataArrayI::Copy(TObject &a) const
 {
   //
   // Copy function
index 11f33d2..d1bf8bf 100644 (file)
@@ -27,7 +27,7 @@ class AliTRDdataArrayI : public AliTRDdataArray {
   AliTRDdataArrayI &operator=(const AliTRDdataArrayI &a);
 
   virtual void   Allocate(Int_t nrow, Int_t ncol, Int_t ntime);
-  virtual void   Copy(TObject &a);
+  virtual void   Copy(TObject &a) const;
   virtual void   Compress(Int_t bufferType, Int_t threshold);
   virtual void   Compress(Int_t bufferType); 
   virtual void   Expand();
index 99206f9..1ed1658 100644 (file)
@@ -241,7 +241,7 @@ AliTRDdigitizer &AliTRDdigitizer::operator=(const AliTRDdigitizer &d)
 }
 
 //_____________________________________________________________________________
-void AliTRDdigitizer::Copy(TObject &d)
+void AliTRDdigitizer::Copy(TObject &d) const
 {
   //
   // Copy function
index 4bbd3d6..a732c56 100644 (file)
@@ -34,7 +34,7 @@ class AliTRDdigitizer : public AliDigitizer {
   virtual ~AliTRDdigitizer();
   AliTRDdigitizer &operator=(const AliTRDdigitizer &d);
 
-  virtual void         Copy(TObject &d);
+  virtual void         Copy(TObject &d) const;
   virtual Bool_t       InitDetector();
   virtual void         Exec(Option_t* option = 0);  
   virtual Bool_t       Open(const Char_t *file, Int_t nEvent = 0);
index 5d1e88f..f5cdf07 100644 (file)
@@ -97,7 +97,7 @@ AliTRDdigitsManager::~AliTRDdigitsManager()
 }
 
 //_____________________________________________________________________________
-void AliTRDdigitsManager::Copy(TObject &m)
+void AliTRDdigitsManager::Copy(TObject &m) const
 {
   //
   // Copy function
index 21418ac..cf53288 100644 (file)
@@ -32,7 +32,7 @@ class AliTRDdigitsManager : public TObject {
 
   virtual void                CreateArrays();
   virtual void                ResetArrays();
-  virtual void                Copy(TObject &m);
+  virtual void                Copy(TObject &m) const;
 
   virtual Bool_t              MakeBranch(TTree *tree);
           
index 9dda6b0..c73c367 100644 (file)
@@ -190,21 +190,32 @@ void AliTRDgeometry::Init()
   Int_t isect;
 
   // The outer width of the chambers
-  fCwidth[0] =  94.8;
-  fCwidth[1] =  99.3;
-  fCwidth[2] = 103.7;
-  fCwidth[3] = 108.1;
-  fCwidth[4] = 112.6;
-  fCwidth[5] = 117.0;
+  //
+  // Changed with the introduction of 
+  // the new layer 0. The old layer 6
+  // is removed.
+  fCwidth[0] =  92.6;
+  fCwidth[1] =  94.8;
+  fCwidth[2] =  99.3;
+  fCwidth[3] = 103.7;
+  fCwidth[4] = 108.1;
+  fCwidth[5] = 112.6;
+  // Old layer 6
+  // fCwidth[5] = 117.0;
 
   // The outer lengths of the chambers
   // Includes the spacings between the chambers!
+  // Changed with the introduction of 
+  // the new layer 0. The old layer 6
+  // is removed.
   Float_t length[kNplan][kNcham]   = { { 124.0, 124.0, 110.0, 124.0, 124.0 }
+                                    , { 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 }
                                      , { 145.0, 145.0, 110.0, 145.0, 145.0 }
-                                     , { 147.0, 147.0, 110.0, 147.0, 147.0 }
-                                     , { 147.0, 147.0, 110.0, 147.0, 147.0 } };
+                                    , { 147.0, 147.0, 110.0, 147.0, 147.0 } };
+  // Old layer 6
+  //                                 , { 147.0, 147.0, 110.0, 147.0, 147.0 } };
 
   for (icham = 0; icham < kNcham; icham++) {
     for (iplan = 0; iplan < kNplan; iplan++) {
@@ -301,19 +312,21 @@ Bool_t AliTRDgeometry::Local2Global(Int_t iplan, Int_t icham, Int_t isect
 
 
 //_____________________________________________________________________________
-Bool_t AliTRDgeometry::Global2Local(Int_t mode, Float_t *local, Float_t *global, Int_t* index,  AliTRDparameter *par) const
+Bool_t AliTRDgeometry::Global2Local(Int_t mode, Float_t *local, Float_t *global
+                                  , Int_t* index,  AliTRDparameter *par) const
 {
   //
   // Converts local pad-coordinates (row,col,time) into 
   // global ALICE reference frame coordinates (x,y,z)
   //
-  //index[0]=plane number
-  //index[1]=chamber number
-  //index[2]=sector number
+  // index[0] = plane number
+  // index[1] = chamber number
+  // index[2] = sector number
   //
   // mode=0  - local coordinate in y, z,             x - rotated global   
   // mode=2  - local coordinate in pad, and pad row, x - rotated global
   //
+
   if (!par) {
     Error("Local2Global","No parameter defined\n");
     return kFALSE;
@@ -346,12 +359,13 @@ Bool_t AliTRDgeometry::Global2Local(Int_t mode, Float_t *local, Float_t *global,
 Bool_t   AliTRDgeometry::Global2Detector(Float_t global[3], Int_t index[3], AliTRDparameter *par)
 {
   //  
+  // input    = global position
+  // output   = index
+  // index[0] = plane number
+  // index[1] = chamber number
+  // index[2] = sector number
   //
-  //input = global position
-  //output =index
-  //index[0]=plane number
-  //index[1]=chamber number
-  //index[2]=sector number
+
   Float_t fi;
   //
   fi = TMath::ATan2(global[1],global[0]);
index 0099ade..02a6f17 100644 (file)
@@ -128,7 +128,7 @@ void AliTRDmatrix::AddSignal(Int_t iRow, Int_t iCol, Int_t iTime, Float_t signal
 }
 
 //_____________________________________________________________________________
-void AliTRDmatrix::Copy(TObject &m)
+void AliTRDmatrix::Copy(TObject &m) const
 {
   //
   // Copy function
index 32edbb2..854ec0a 100644 (file)
@@ -30,7 +30,7 @@ public:
   virtual void         AddSignal(Int_t iRow, Int_t iCol, Int_t iTime, Float_t signal);
   virtual Bool_t       AddTrack(Int_t iRow, Int_t iCol, Int_t iTime, Int_t track);
 
-  virtual void         Copy(TObject &m);
+  virtual void         Copy(TObject &m) const;
   virtual void         Draw(Option_t *opt = " ");
   virtual void         DrawRow(Int_t iRow);
   virtual void         DrawCol(Int_t iCol);
diff --git a/TRD/AliTRDpadPlane.cxx b/TRD/AliTRDpadPlane.cxx
new file mode 100644 (file)
index 0000000..470a72f
--- /dev/null
@@ -0,0 +1,461 @@
+/**************************************************************************
+ * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ *                                                                        *
+ * Author: The ALICE Off-line Project.                                    *
+ * Contributors are mentioned in the code where appropriate.              *
+ *                                                                        *
+ * Permission to use, copy, modify and distribute this software and its   *
+ * documentation strictly for non-commercial purposes is hereby granted   *
+ * without fee, provided that the above copyright notice appears in all   *
+ * copies and that both the copyright notice and this permission notice   *
+ * appear in the supporting documentation. The authors make no claims     *
+ * about the suitability of this software for any purpose. It is          *
+ * provided "as is" without express or implied warranty.                  *
+ **************************************************************************/
+
+/* $Id$ */
+
+///////////////////////////////////////////////////////////////////////////////
+//                                                                           //
+//  Describes a pad plane of a TRD ROC                                       //
+//                                                                           //
+//  Contains the information on pad postions, pad dimensions,                //
+//  tilting angle, etc.                                                      //
+//  It also provides methods to identify the current pad number from         //
+//  global coordinates.                                                      //
+//                                                                           //
+///////////////////////////////////////////////////////////////////////////////
+
+#include "AliTRDpadPlane.h"
+#include "AliTRDgeometryFull.h"
+
+ClassImp(AliTRDpadPlane)
+
+//_____________________________________________________________________________
+AliTRDpadPlane::AliTRDpadPlane():TObject()
+{
+  //
+  // Default constructor
+  //
+
+  fGeo          = 0;
+
+  fPla          = 0;
+  fCha          = 0;
+
+  fLength       = 0.0;
+  fWidth        = 0.0;
+  fLengthRim    = 0.0;
+  fWidthRim     = 0.0;
+  fLengthOPad   = 0.0;
+  fWidthOPad    = 0.0;
+  fLengthIPad   = 0.0;
+  fWidthIPad    = 0.0;
+
+  fRowSpacing   = 0.0;
+  fColSpacing   = 0.0;
+
+  fNrows        = 0;
+  fNcols        = 0;
+
+  fPadRow       = 0;
+  fPadCol       = 0;
+
+  fTiltingAngle = 0.0;
+
+}
+
+//_____________________________________________________________________________
+AliTRDpadPlane::AliTRDpadPlane(Int_t p, Int_t c):TObject()
+{
+  //
+  // Constructor that initializes a given pad plane type
+  //
+
+  fGeo = new AliTRDgeometryFull();
+
+  fPla = p;
+  fCha = c;
+
+  //fRowSpacing = 0.025;
+  //fColSpacing = 0.025;
+
+  fRowSpacing = 0.0;
+  fColSpacing = 0.0;
+
+  fLengthRim  = 1.0;
+  fWidthRim   = 0.5;
+
+  fNcols      = 144;
+
+  //
+  // The pad plane parameter
+  //
+  switch (p) {
+  case 0:
+    if (c == 2) {
+      // L0C0 type
+      fNrows        =  12;
+      fLength       = 108.0;
+      fWidth        =  94.4;
+      fLengthOPad   =   8.0;
+      fWidthOPad    =   0.515;
+      fLengthIPad   =   9.0;
+      fWidthIPad    =   0.635;
+      fTiltingAngle =  -2.0;
+    }
+    else {
+      // L0C1 type
+      fNrows        =  16;
+      fLength       = 122.0;
+      fWidth        =  94.4;
+      fLengthOPad   =   7.5;
+      fWidthOPad    =   0.515;
+      fLengthIPad   =   7.5;
+      fWidthIPad    =   0.635;
+      fTiltingAngle =  -2.0;
+    }
+    break;
+  case 1:
+    if (c == 2) {
+      // L1C0 type
+      fNrows        =  12;
+      fLength       = 108.0;
+      fWidth        =  96.6;
+      fLengthOPad   =   8.0;
+      fWidthOPad    =   0.585;
+      fLengthIPad   =   9.0;
+      fWidthIPad    =   0.665;
+      fTiltingAngle =   2.0;
+    }
+    else {
+      // L1C1 type
+      fNrows        =  16;
+      fLength       = 122.0;
+      fWidth        =  96.6;
+      fLengthOPad   =   7.5;
+      fWidthOPad    =   0.585;
+      fLengthIPad   =   7.5;
+      fWidthIPad    =   0.665;
+      fTiltingAngle =   2.0;
+    }
+    break;
+  case 2:
+    if (c == 2) {
+      // L2C0 type
+      fNrows        =  12;
+      fLength       = 108.0;
+      fWidth        = 101.1;
+      fLengthOPad   =   8.0;
+      fWidthOPad    =   0.705;
+      fLengthIPad   =   9.0;
+      fWidthIPad    =   0.695;
+      fTiltingAngle =  -2.0;
+    }
+    else {
+      // L2C1 type
+      fNrows        =  16;
+      fLength       = 129.0;
+      fWidth        = 101.1;
+      fLengthOPad   =   7.5;
+      fWidthOPad    =   0.705;
+      fLengthIPad   =   8.0;
+      fWidthIPad    =   0.695;
+      fTiltingAngle =  -2.0;
+    }
+    break;
+  case 3:
+    if (c == 2) {
+      // L3C0 type
+      fNrows        =  12;
+      fLength       = 108.0;
+      fWidth        = 105.5;
+      fLengthOPad   =   8.0;
+      fWidthOPad    =   0.775;
+      fLengthIPad   =   9.0;
+      fWidthIPad    =   0.725;
+      fTiltingAngle =   2.0;
+    }
+    else {
+      // L3C1 type
+      fNrows        =  16;
+      fLength       = 136.0;
+      fWidth        = 105.5;
+      fLengthOPad   =   7.5;
+      fWidthOPad    =   0.775;
+      fLengthIPad   =   8.5;
+      fWidthIPad    =   0.725;
+      fTiltingAngle =   2.0;
+    }
+    break;
+  case 4:
+    if (c == 2) {
+      // L4C0 type
+      fNrows        =  12;
+      fLength       = 108.0;
+      fWidth        = 109.9;
+      fLengthOPad   =   8.0;
+      fWidthOPad    =   0.845;
+      fLengthIPad   =   9.0;
+      fWidthIPad    =   0.755;
+      fTiltingAngle =  -2.0;
+    }
+    else {
+      // L4C1 type
+      fNrows        =  16;
+      fLength       = 143.0;
+      fWidth        = 109.9;
+      fLengthOPad   =   7.5;
+      fWidthOPad    =   0.845;
+      fLengthIPad   =   9.0;
+      fWidthIPad    =   0.755;
+      fTiltingAngle =  -2.0;
+    }
+    break;
+  case 5:
+    if (c == 2) {
+      // L5C0 type
+      fNrows        =  12;
+      fLength       = 108.0;
+      fWidth        = 114.4;
+      fLengthOPad   =   8.0;
+      fWidthOPad    =   0.965;
+      fLengthIPad   =   9.0;
+      fWidthIPad    =   0.785;
+      fTiltingAngle =   2.0;
+    }
+    else {
+      // L5C1 type
+      fNrows        =  16;
+      fLength       = 145.0;
+      fWidth        = 114.4;
+      fLengthOPad   =   8.5;
+      fWidthOPad    =   0.965;
+      fLengthIPad   =   9.0;
+      fWidthIPad    =   0.785;
+      fTiltingAngle =   2.0;
+    }
+    break;
+  };
+
+  //
+  // The positions of the borders of the pads
+  //
+  // Row direction
+  //
+  if (fPadRow) delete [] fPadRow;
+  fPadRow = new Double_t[fNrows];
+  Double_t row = fGeo->GetChamberLength(p,0)
+              + fGeo->GetChamberLength(p,1)
+               + fGeo->GetChamberLength(p,2) / 2.
+               - fLengthRim;
+  for (Int_t ic = 0; ic < c; ic++) {
+    row -= fGeo->GetChamberLength(p,ic);
+  }
+  for (Int_t ir = 0; ir < fNrows; ir++) {
+    fPadRow[ir] = row;
+    row -= fRowSpacing;
+    if (ir == 1) {
+      row -= fLengthOPad;
+    }
+    else {
+      row -= fLengthIPad;
+    }
+  }
+  //
+  // Column direction
+  //
+  if (fPadCol) delete [] fPadCol;
+  fPadCol = new Double_t[fNcols];
+  Double_t col = fGeo->GetChamberWidth(p) / 2. 
+               - fWidthRim;
+  for (Int_t ic = 0; ic < fNcols; ic++) {
+    fPadCol[ic] = col;
+    col -= fColSpacing;
+    if (ic == 1) {
+      col -= fWidthOPad;
+    }
+    else {
+      col -= fWidthIPad;
+    }
+  }
+
+}
+
+//_____________________________________________________________________________
+AliTRDpadPlane::AliTRDpadPlane(const AliTRDpadPlane &p):TObject(p)
+{
+  //
+  // AliTRDpadPlane copy constructor
+  //
+
+  ((AliTRDpadPlane &) p).Copy(*this);
+
+}
+
+//_____________________________________________________________________________
+AliTRDpadPlane::~AliTRDpadPlane()
+{
+  //
+  // AliTRDpadPlane destructor
+  //
+
+  if (fGeo) {
+    delete fGeo;
+    fGeo    = 0;
+  }
+
+  if (fPadRow) {
+    delete [] fPadRow;
+    fPadRow = 0;
+  }
+
+  if (fPadCol) {
+    delete [] fPadCol;
+    fPadCol = 0;
+  }
+
+}
+
+//_____________________________________________________________________________
+void AliTRDpadPlane::Copy(TObject &p) const
+{
+  //
+  // Copy function
+  //
+
+  Int_t iBin = 0;
+
+  ((AliTRDpadPlane &) p).fGeo          = 0;
+
+  ((AliTRDpadPlane &) p).fPla          = fPla;
+  ((AliTRDpadPlane &) p).fCha          = fCha;
+
+  ((AliTRDpadPlane &) p).fLength       = fLength;
+  ((AliTRDpadPlane &) p).fWidth        = fWidth;
+  ((AliTRDpadPlane &) p).fLengthRim    = fLengthRim;
+  ((AliTRDpadPlane &) p).fWidthRim     = fWidthRim;
+  ((AliTRDpadPlane &) p).fLengthOPad   = fLengthOPad;
+  ((AliTRDpadPlane &) p).fWidthOPad    = fWidthOPad;
+  ((AliTRDpadPlane &) p).fLengthIPad   = fLengthIPad;
+  ((AliTRDpadPlane &) p).fWidthIPad    = fWidthIPad;
+
+  ((AliTRDpadPlane &) p).fRowSpacing   = fRowSpacing;
+  ((AliTRDpadPlane &) p).fColSpacing   = fColSpacing;
+
+  ((AliTRDpadPlane &) p).fNrows        = fNrows;
+  ((AliTRDpadPlane &) p).fNcols        = fNcols;
+
+  ((AliTRDpadPlane &) p).fTiltingAngle = fTiltingAngle;
+
+  if (((AliTRDpadPlane &) p).fPadRow) delete [] ((AliTRDpadPlane &) p).fPadRow;
+  ((AliTRDpadPlane &) p).fPadRow = new Double_t[fNrows];
+  for (iBin = 0; iBin < fNrows; iBin++) {
+    ((AliTRDpadPlane &) p).fPadRow[iBin] = fPadRow[iBin];
+  }                                                                             
+
+  if (((AliTRDpadPlane &) p).fPadCol) delete [] ((AliTRDpadPlane &) p).fPadCol;
+  ((AliTRDpadPlane &) p).fPadCol = new Double_t[fNrows];
+  for (iBin = 0; iBin < fNrows; iBin++) {
+    ((AliTRDpadPlane &) p).fPadCol[iBin] = fPadCol[iBin];
+  }                                                                             
+
+  TObject::Copy(p);
+
+}
+
+//_____________________________________________________________________________
+Int_t AliTRDpadPlane::GetPadRowNumber(const Double_t z)
+{
+  //
+  // Finds the pad row number for a given global z-position
+  //
+
+  Int_t row    = 0;
+  Int_t nabove = 0;
+  Int_t nbelow = 0;
+  Int_t middle = 0;
+
+  if ((z > fPadRow[0]) ||
+      (z < fPadRow[0] - fLength + 2.0*fLengthRim)) {
+    row = -1;
+  }
+  else {
+    nabove = fNrows+1;
+    nbelow = 0;
+    while (nabove - nbelow > 1) {
+      middle = (nabove + nbelow) / 2;
+      if (z == fPadRow[middle-1]) row    = middle;
+      if (z  > fPadRow[middle-1]) nabove = middle;
+      else                        nbelow = middle;
+    }
+    row = nbelow - 1;
+  }
+
+  return row;
+
+}
+
+//_____________________________________________________________________________
+Int_t AliTRDpadPlane::GetPadColNumber(const Double_t rphi)
+{
+  //
+  // Finds the pad column number for a given global rphi-position
+  //
+
+  Int_t col    = 0;
+  Int_t nabove = 0;
+  Int_t nbelow = 0;
+  Int_t middle = 0;
+
+  if ((rphi > fPadCol[0]) ||
+      (rphi < fPadCol[0] - fWidth + 2.0*fWidthRim)) {
+    col = -1;
+  }
+  else {
+    nabove = fNcols+1;
+    nbelow = 0;
+    while (nabove - nbelow > 1) {
+      middle = (nabove + nbelow) / 2;
+      if (rphi == fPadCol[middle-1]) col    = middle;
+      if (rphi  > fPadCol[middle-1]) nabove = middle;
+      else                           nbelow = middle;
+    }
+    col = nbelow - 1;
+  }
+
+  return col;
+
+}
+
+//_____________________________________________________________________________
+Double_t AliTRDpadPlane::GetPadRowOffset(const Int_t row, const Double_t z)
+{
+  //
+  // Calculates the distance to the pad border in row direction
+  //
+
+  if ((row < 0) || (row >= fNrows)) {
+    return -1.0;
+  }
+  else {
+    return fPadRow[row] - z;
+  }
+
+}
+
+//_____________________________________________________________________________
+Double_t AliTRDpadPlane::GetPadColOffset(const Int_t col, const Double_t rphi)
+{
+  //
+  // Calculates the distance to the pad border in column direction
+  //
+
+  if ((col < 0) || (col >= fNcols)) {
+    return -1.0;
+  }
+  else {
+    return fPadCol[col] - rphi;
+  }
+
+}
diff --git a/TRD/AliTRDpadPlane.h b/TRD/AliTRDpadPlane.h
new file mode 100644 (file)
index 0000000..3c15b78
--- /dev/null
@@ -0,0 +1,75 @@
+#ifndef ALITRDPADPLANE_H
+#define ALITRDPADPLANE_H
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                               */
+
+/* $Id: AliTRDpadPlane.h,v */
+
+//////////////////////////////////////////////////
+//                                              //
+//  TRD pad plane class                         //
+//                                              //
+//  Contains the information on pad postions,   //
+//  pad dimensions, tilting angle, etc.         //
+//  It also provides methods to identify the    //
+//  current pad number from global coordinates. //
+//                                              //
+//////////////////////////////////////////////////
+
+#include <TObject.h>
+
+class AliTRDgeometry;
+
+//_____________________________________________________________________________
+class AliTRDpadPlane : public TObject {
+
+ public:
+
+  AliTRDpadPlane();
+  AliTRDpadPlane(Int_t p, Int_t c);
+  AliTRDpadPlane(const AliTRDpadPlane &p);
+  virtual           ~AliTRDpadPlane();
+  AliTRDpadPlane    &operator=(const AliTRDpadPlane &p);
+  virtual void       Copy(TObject &p) const;
+
+  Int_t    GetPadRowNumber(const Double_t z);
+  Int_t    GetPadColNumber(const Double_t rphi);
+
+  Double_t GetPadRowOffset(const Int_t row, const Double_t z);
+  Double_t GetPadColOffset(const Int_t col, const Double_t rphi);
+  
+ protected:
+
+  AliTRDgeometry *fGeo;       //! TRD geometry       
+
+  Int_t     fPla;             //  Plane number
+  Int_t     fCha;             //  Chamber number
+
+  Double_t  fLength;          //  Length of pad plane in z-direction (row)
+  Double_t  fWidth;           //  Width of pad plane in rphi-direction (col)
+
+  Double_t  fLengthRim;       //  Length of the rim in z-direction (row)
+  Double_t  fWidthRim;        //  Width of the rim in rphi-direction (col)
+
+  Double_t  fLengthOPad;      //  Length of an outer pad in z-direction (row)
+  Double_t  fWidthOPad;       //  Width of an outer pad in rphi-direction (col)
+
+  Double_t  fLengthIPad;      //  Length of an inner pad in z-direction (row)
+  Double_t  fWidthIPad;       //  Width of an inner pad in rphi-direction (col)
+
+  Double_t  fRowSpacing;      //  Spacing between the pad rows
+  Double_t  fColSpacing;      //  Spacing between the pad columns
+
+  Int_t     fNrows;           //  Number of rows
+  Int_t     fNcols;           //  Number of columns
+
+  Double_t  fTiltingAngle;    //  Pad tilting angle  
+
+  Double_t *fPadRow;          //! Pad border positions in row direction
+  Double_t *fPadCol;          //! Pad border positions in column direction
+
+  ClassDef(AliTRDpadPlane,1)  //  TRD ROC pad plane
+
+};
+
+#endif
index 6c30f82..51e24f6 100644 (file)
@@ -212,7 +212,7 @@ AliTRDparameter &AliTRDparameter::operator=(const AliTRDparameter &p)
 }
 
 //_____________________________________________________________________________
-void AliTRDparameter::Copy(TObject &p)
+void AliTRDparameter::Copy(TObject &p) const
 {
   //
   // Copy function
@@ -328,13 +328,6 @@ void AliTRDparameter::Init()
   //
 
   // The pad size in column direction (rphi-direction)
-  //SetColPadSize(0,0.65);
-  //SetColPadSize(1,0.68);
-  //SetColPadSize(2,0.71);
-  //SetColPadSize(3,0.74);
-  //SetColPadSize(4,0.77);
-  //SetColPadSize(5,0.80);
-
   SetColPadSize(0,0.664);
   SetColPadSize(1,0.695);
   SetColPadSize(2,0.726);
index a89b9c6..07bba85 100644 (file)
@@ -27,7 +27,7 @@ class AliTRDparameter : public TNamed {
   virtual ~AliTRDparameter();
   AliTRDparameter &operator=(const AliTRDparameter &p); 
 
-  virtual void     Copy(TObject &p);
+  virtual void     Copy(TObject &p) const;
   virtual void     Init();
   virtual void     ReInit();
  
index 0f25a7d..090ce93 100644 (file)
@@ -136,7 +136,7 @@ AliTRDpid &AliTRDpid::operator=(const AliTRDpid &p)
 }
 
 //_____________________________________________________________________________
-void AliTRDpid::Copy(TObject &p)
+void AliTRDpid::Copy(TObject &p) const
 {
   //
   // Copy function
index 00d00a1..a0b2015 100644 (file)
@@ -32,7 +32,7 @@ class AliTRDpid : public TNamed {
   virtual ~AliTRDpid();
   AliTRDpid &operator=(const AliTRDpid &p);
 
-  virtual void          Copy(TObject &p);
+  virtual void          Copy(TObject &p) const;
   virtual Bool_t        Init();
   virtual Bool_t        AssignLikelihood();
   virtual Bool_t        AssignLikelihood(TObjArray *tarray);
index c89044c..c3e0f05 100644 (file)
@@ -129,7 +129,7 @@ AliTRDpidLQ &AliTRDpidLQ::operator=(const AliTRDpidLQ &p)
 }
 
 //_____________________________________________________________________________
-void AliTRDpidLQ::Copy(TObject &p)
+void AliTRDpidLQ::Copy(TObject &p) const
 {
   //
   // Copy function
index 89c73df..42a126a 100644 (file)
@@ -29,15 +29,19 @@ class AliTRDpidLQ : public AliTRDpid {
   virtual ~AliTRDpidLQ();
   AliTRDpidLQ &operator=(const AliTRDpidLQ &p);
 
-  virtual void          Copy(TObject &p);
+  virtual void          Copy(TObject &p) const;
   virtual Bool_t        Init();
+  virtual Bool_t        AssignLikelihood()            { return 0; };
+  virtual Bool_t        AssignLikelihood(TObjArray *) { return 0; };
   virtual Bool_t        AssignLikelihood(AliTRDtrack *t);
   virtual Bool_t        CreateHistograms(Int_t nmom, Float_t minmom, Float_t maxmom);
+  virtual Bool_t        FillSpectra()                 { return 0; };
+  virtual Bool_t        FillSpectra(TObjArray*)       { return 0; };
   virtual Bool_t        FillSpectra(const AliTRDtrack *t);
 
-  Int_t         GetIndex(const AliTRDtrack *t);
-  Int_t         GetIndex(Int_t imom, Int_t ipid);
-  Int_t         GetIndex(Float_t mom, Int_t ipid);
+          Int_t         GetIndex(const AliTRDtrack *t);
+          Int_t         GetIndex(Int_t imom, Int_t ipid);
+          Int_t         GetIndex(Float_t mom, Int_t ipid);
 
           TObjArray*    GetHist() const                     { return fHist;        };
 
index c2a470a..9d50508 100644 (file)
@@ -54,7 +54,7 @@ AliTRDpixel::~AliTRDpixel()
 }
 
 //_____________________________________________________________________________
-void AliTRDpixel::Copy(TObject &p)
+void AliTRDpixel::Copy(TObject &p) const
 {
   //
   // Copy function
index 22b91d3..aabfe13 100644 (file)
@@ -18,7 +18,7 @@ public:
   AliTRDpixel();
   virtual ~AliTRDpixel();
 
-  virtual void    Copy(TObject &p);
+  virtual void    Copy(TObject &p) const;
 
   static  Int_t   NTrackPixel()                  { return fgkNTrackPixel; };
 
index 60ae048..e25ca2f 100644 (file)
@@ -91,7 +91,7 @@ AliTRDpoints &AliTRDpoints::operator=(const AliTRDpoints &p)
 }
 
 //_____________________________________________________________________________
-void AliTRDpoints::Copy(TObject &p)
+void AliTRDpoints::Copy(TObject &p) const
 {
   //
   // Copy function
index 6cdeb84..0f9b9ff 100644 (file)
@@ -24,7 +24,7 @@ class AliTRDpoints : public AliPoints {
   virtual ~AliTRDpoints();
   AliTRDpoints &operator=(const AliTRDpoints &p);
 
-  virtual void           Copy(TObject &p);   
+  virtual void           Copy(TObject &p) const;   
   virtual void           Draw(Option_t *option);
 
   virtual void           SetTRpoints(Int_t n, Float_t *coor);
index 69b6bd1..573a4f4 100644 (file)
@@ -77,7 +77,7 @@ AliTRDrawData &AliTRDrawData::operator=(const AliTRDrawData &r)
 }
 
 //_____________________________________________________________________________
-void AliTRDrawData::Copy(TObject &r)
+void AliTRDrawData::Copy(TObject &r) const
 {
   //
   // Copy function
index 4e042f4..38d36b3 100644 (file)
@@ -26,7 +26,7 @@ class AliTRDrawData : public TObject {
   virtual ~AliTRDrawData();
   AliTRDrawData &operator=(const AliTRDrawData &r);
 
-  virtual void                 Copy(TObject &r);
+  virtual void                 Copy(TObject &r) const;
 
   virtual Bool_t               Digits2Raw(TTree *digits);
   virtual AliTRDdigitsManager* Raw2Digits(AliRawReader* rawReader);
index 7d86b32..2763706 100644 (file)
@@ -80,7 +80,7 @@ AliTRDsegmentArray::~AliTRDsegmentArray()
 }
 
 //_____________________________________________________________________________
-void AliTRDsegmentArray::Copy(TObject &a)
+void AliTRDsegmentArray::Copy(TObject &a) const
 {
   //
   // Copy function
index bcd028a..b334951 100644 (file)
@@ -25,7 +25,7 @@ class AliTRDsegmentArray : public AliTRDsegmentArrayBase {
   AliTRDsegmentArray(AliTRDsegmentArray &a);
   virtual ~AliTRDsegmentArray();
 
-  virtual void             Copy(TObject &a);
+  virtual void             Copy(TObject &a) const;
   virtual void             Delete();
   virtual void             Delete(const char *) { Delete(); };
 
index cc52a5c..9565baa 100644 (file)
@@ -118,7 +118,7 @@ AliTRDsegmentArrayBase &AliTRDsegmentArrayBase
 }
 
 //_____________________________________________________________________________
-void AliTRDsegmentArrayBase::Copy(TObject &a)
+void AliTRDsegmentArrayBase::Copy(TObject &a) const
 {
   //
   // Copy function
index c4b7d7e..6dcd095 100644 (file)
@@ -33,7 +33,7 @@ class AliTRDsegmentArrayBase: public TNamed {
           Bool_t           AddSegment(AliTRDsegmentID *segment);
           AliTRDsegmentID *AddSegment(Int_t index);  
           void             ClearSegment(Int_t index); 
-  virtual void             Copy(TObject &a);
+  virtual void             Copy(TObject &a) const;
   virtual Bool_t           ConnectTree(const char *treeName);
           Bool_t           MakeArray(Int_t n);    
   virtual AliTRDsegmentID *NewSegment(); 
index da81d49..67eee53 100644 (file)
@@ -23,7 +23,7 @@ class AliTRDsegmentID : public TObject {
   virtual ~AliTRDsegmentID();
 
           Int_t  GetID() const      { return fSegmentID;    }
-  virtual Int_t  GetSize()          { return sizeof(*this); }
+  virtual Int_t  GetSize() const    { return sizeof(*this); }
 
           void   SetID(Int_t index) { fSegmentID = index;} 
 
index 8dbc34f..85190e0 100644 (file)
@@ -132,7 +132,7 @@ AliTRDsim &AliTRDsim::operator=(const AliTRDsim &s)
 }
 
 //_____________________________________________________________________________
-void AliTRDsim::Copy(TObject &s)
+void AliTRDsim::Copy(TObject &s) const
 {
   //
   // Copy function
index 5ee83be..33f28fc 100644 (file)
@@ -27,7 +27,7 @@ class AliTRDsim : public TObject {
   virtual ~AliTRDsim();
   AliTRDsim &operator=(const AliTRDsim &s);
 
-  virtual void          Copy(TObject &s);
+  virtual void          Copy(TObject &s) const;
   virtual void          Init();
   virtual Int_t         CreatePhotons(Int_t pdg, Float_t p
                                     , Int_t &nPhoton, Float_t *ePhoton);
index cf66d73..42c69d6 100644 (file)
@@ -91,7 +91,7 @@ void AliTRDsimple::Init()
 }
  
 //_____________________________________________________________________________
-void AliTRDsimple::Copy(TObject &s)
+void AliTRDsimple::Copy(TObject &s) const
 {
   //
   // Copy function
index 7637630..5f1c271 100644 (file)
@@ -26,7 +26,7 @@ class AliTRDsimple : public TObject {
   AliTRDsimple &operator=(const AliTRDsimple &s);    
 
   virtual void             Init();
-  virtual void             Copy(TObject &s);
+  virtual void             Copy(TObject &s) const;
   virtual void             ProcessEvent(Int_t ievent);
 
   virtual AliTRDsimpleGen *GetGenerator()      const { return fGenerator; };
index 0879712..b0aecca 100644 (file)
@@ -80,7 +80,7 @@ AliTRDsimpleGen &AliTRDsimpleGen::operator=(const AliTRDsimpleGen &g)
 }
  
 //_____________________________________________________________________________
-void AliTRDsimpleGen::Copy(TObject &g)
+void AliTRDsimpleGen::Copy(TObject &g) const
 {
   //
   // Copy function
index 0d63bdb..19553f0 100644 (file)
@@ -23,7 +23,7 @@ class AliTRDsimpleGen : public TObject {
   virtual ~AliTRDsimpleGen();
   AliTRDsimpleGen &operator=(const AliTRDsimpleGen &g);    
 
-  virtual void         Copy(TObject &g);
+  virtual void         Copy(TObject &g) const;
   virtual void         NewParticle(Int_t ievent);
 
   virtual void         SetMomentum(Double_t min, Double_t max) { fMomMin = min;
index 9f2c816..8a2fe1e 100644 (file)
@@ -127,7 +127,7 @@ AliTRDsimpleMC &AliTRDsimpleMC::operator=(const AliTRDsimpleMC &m)
 }
  
 //_____________________________________________________________________________
-void AliTRDsimpleMC::Copy(TObject &m)
+void AliTRDsimpleMC::Copy(TObject &m) const
 {
   //
   // Copy function
index 9b7a6d9..3d32d87 100644 (file)
@@ -35,7 +35,7 @@ class AliTRDsimpleMC : public TVirtualMC {
   virtual ~AliTRDsimpleMC();
   AliTRDsimpleMC &operator=(const AliTRDsimpleMC &m);
 
-  virtual void          Copy(TObject &m);
+  virtual void          Copy(TObject &m) const;
 
   //
   // Methods for building / management of geometry
index 7b15eeb..579d4f0 100644 (file)
@@ -62,6 +62,7 @@ public:
    Double_t GetP()     const {  
      return TMath::Abs(GetPt())*sqrt(1.+GetTgl()*GetTgl());
    }
+   virtual  Double_t GetPredictedChi2(const AliCluster*) const { return 0.0; };
    Double_t GetPredictedChi2(const AliTRDcluster *c, Double_t h01) const ;
    Double_t GetPt()    const {return 1./Get1Pt();}   
    void     GetPxPyPz(Double_t &px, Double_t &py, Double_t &pz) const ;
@@ -117,6 +118,7 @@ public:
 
    void     SetSeedLabel(Int_t lab) { fSeedLab=lab; }
 
+   Int_t    Update(const AliCluster*, Double_t, UInt_t) { return 0; };
    Int_t    Update(const AliTRDcluster* c, Double_t chi2, UInt_t i, 
                    Double_t h01);
    Int_t    UpdateMI(const AliTRDcluster* c, Double_t chi2, UInt_t i, 
index c269d43..c75f85d 100644 (file)
@@ -130,7 +130,7 @@ AliTRDv1 &AliTRDv1::operator=(const AliTRDv1 &trd)
 }
  
 //_____________________________________________________________________________
-void AliTRDv1::Copy(TObject &trd)
+void AliTRDv1::Copy(TObject &trd) const
 {
   //
   // Copy function
@@ -762,7 +762,7 @@ void AliTRDv1::StepManagerFixedStep()
   Int_t idChamber = (atoi(cIdChamber) % kNdetsec);
   cha = ((Int_t) idChamber / kNplan);
   pla = ((Int_t) idChamber % kNplan);
-  
+
   // Check on selected volumes
   Int_t addthishit = 1;
   if(fSensSelect) {
index 7365aaa..346dbd4 100644 (file)
@@ -30,7 +30,7 @@ class AliTRDv1 : public AliTRD {
   virtual ~AliTRDv1();
   AliTRDv1 &operator=(const AliTRDv1 &trd);
 
-  virtual void       Copy(TObject &trd);
+  virtual void       Copy(TObject &trd) const;
   virtual void       CreateGeometry();
   virtual void       CreateMaterials();
   virtual void       CreateTRhit(Int_t det);
index 586c5eb..4fc6df3 100644 (file)
@@ -104,7 +104,7 @@ AliTRDv2 &AliTRDv2::operator=(const AliTRDv2 &trd)
 }
  
 //_____________________________________________________________________________
-void AliTRDv2::Copy(TObject &trd)
+void AliTRDv2::Copy(TObject &trd) const
 {
   //
   // Copy function
index a2ce971..26bb4ec 100644 (file)
@@ -22,7 +22,7 @@ class AliTRDv2 : public AliTRDv1 {
   virtual ~AliTRDv2();
   AliTRDv2 &operator=(const AliTRDv2 &trd);
 
-  virtual void       Copy(TObject &trd);
+  virtual void       Copy(TObject &trd) const;
   virtual void       CreateGeometry();
   virtual void       CreateMaterials();
   virtual Int_t      IsVersion() const          { return 2; };