Change in the geometry of the padplane

diff --git a/TRD/AliTRDclusterizerV0.cxx b/TRD/AliTRDclusterizerV0.cxx
index 361ac5e5487af3ec46da500cecbe72b373bfa1be..6162866d134f33e5e0448232617e557098cb6f6a 100644 (file)
--- a/TRD/AliTRDclusterizerV0.cxx
+++ b/TRD/AliTRDclusterizerV0.cxx
@@ -15,6 +15,9 @@
 
 /*
 $Log$
+Revision 1.6  2000/11/01 14:53:20  cblume
+Merge with TRD-develop
+
 Revision 1.1.4.6  2000/10/16 01:16:53  cblume
 Changed timebin 0 to be the one closest to the readout
 
@@ -179,8 +182,8 @@ Bool_t AliTRDclusterizerV0::MakeClusters()
         Float_t col0        = geo->GetCol0(iplan);
         Float_t time0       = geo->GetTime0(iplan);
 
-        Float_t rowPadSize  = geo->GetRowPadSize();
-        Float_t colPadSize  = geo->GetColPadSize();
+        Float_t rowPadSize  = geo->GetRowPadSize(iplan,icham,isect);
+        Float_t colPadSize  = geo->GetColPadSize(iplan);
         Float_t timeBinSize = geo->GetTimeBinSize();
 
         // Loop through all entries in the tree

diff --git a/TRD/AliTRDdigitizer.cxx b/TRD/AliTRDdigitizer.cxx
index 1bfa27f8724d7a8c05c9ba3918655686f0ed5983..5313987999d3b27284436a63b1a88bad87fbb78f 100644 (file)
--- a/TRD/AliTRDdigitizer.cxx
+++ b/TRD/AliTRDdigitizer.cxx
@@ -15,6 +15,9 @@
 
 /*
 $Log$
+Revision 1.18  2001/01/26 19:56:57  hristov
+Major upgrade of AliRoot code
+
 Revision 1.17  2000/12/08 12:53:27  cblume
 Change in Copy() function for HP-compiler
 
@@ -579,7 +582,7 @@ Bool_t AliTRDdigitizer::MakeDigits()
   const Int_t kNDict = AliTRDdigitsManager::kNDict;
 
   Int_t   iRow, iCol, iTime;
-  Int_t   iDict;
+  Int_t   iDict  = 0;
   Int_t   nBytes = 0;
 
   Int_t   totalSizeDigits = 0;
@@ -674,8 +677,8 @@ Bool_t AliTRDdigitizer::MakeDigits()
       Float_t row0        = fGeo->GetRow0(plane,chamber,sector);
       Float_t col0        = fGeo->GetCol0(plane);
       Float_t time0       = fGeo->GetTime0(plane);
-      Float_t rowPadSize  = fGeo->GetRowPadSize();
-      Float_t colPadSize  = fGeo->GetColPadSize();
+      Float_t rowPadSize  = fGeo->GetRowPadSize(plane,chamber,sector);
+      Float_t colPadSize  = fGeo->GetColPadSize(plane);
       Float_t timeBinSize = fGeo->GetTimeBinSize();
 
       if (fVerbose > 1) {
@@ -875,16 +878,35 @@ Bool_t AliTRDdigitizer::MakeDigits()
 
           // Store the track index in the dictionary
           // Note: We store index+1 in order to allow the array to be compressed
-          for (iDict = 0; iDict < kNDict; iDict++) {
-            Int_t oldTrack = dictionary[iDict]->GetData(rowE,colE,timeE);
-            if (oldTrack == track+1) break;
-            //if (oldTrack ==      -1) break;
-            if (oldTrack ==       0) {
-              dictionary[iDict]->SetData(rowE,colE,timeE,track+1);
-              if (fVerbose > 3) {
-                printf("    track index = %d\n",track); 
-             }
-              break;
+          //for (iDict = 0; iDict < kNDict; iDict++) {
+          //  Int_t oldTrack = dictionary[iDict]->GetData(rowE,colE,timeE);
+          //  if (oldTrack == track+1) break;
+          //  //if (oldTrack ==      -1) break;
+          //  if (oldTrack ==       0) {
+          //    dictionary[iDict]->SetData(rowE,colE,timeE,track+1);
+          //    if (fVerbose > 3) {
+          //      printf("    track index = %d\n",track); 
+         //    }
+          //    break;
+          //  }
+          //}
+          for (Int_t iPad = 0; iPad < kNpad; iPad++) {
+            Int_t colPos = colE + iPad - 1;
+            if (colPos <        0) continue;
+            if (colPos >= nColMax) break;
+            if (signals->GetData(rowE,colPos,iTimeBin) > 0) {
+              for (iDict = 0; iDict < kNDict; iDict++) {
+                Int_t oldTrack = dictionary[iDict]->GetData(rowE,colPos,iTimeBin);
+                if (oldTrack == track+1) break;
+                //if (oldTrack ==      -1) break;
+                if (oldTrack ==       0) {
+                  dictionary[iDict]->SetData(rowE,colPos,iTimeBin,track+1);
+                  if (fVerbose > 3) {
+                    printf("    track index = %d\n",track); 
+                  }
+                  break;
+                }
+              }
             }
           }
           if ((fVerbose > 1) && (iDict == kNDict)) {
@@ -1060,7 +1082,7 @@ Bool_t AliTRDdigitizer::WriteDigits()
   fDigits->WriteDigits();
 
   // Write the new tree into the input file (use overwrite option)
-  Char_t treeName[7];
+  Char_t treeName[15];
   sprintf(treeName,"TreeD%d",fEvent);
   printf("AliTRDdigitizer::WriteDigits -- ");
   printf("Write the digits tree %s for event %d.\n"

diff --git a/TRD/AliTRDgeometry.cxx b/TRD/AliTRDgeometry.cxx
index 2e7b38063658cdf2c3deb95eaeb95a6aef16391f..ef9cb529485a3eafc9c1c3c8dbe90a7142f7be39 100644 (file)
--- a/TRD/AliTRDgeometry.cxx
+++ b/TRD/AliTRDgeometry.cxx
@@ -15,6 +15,9 @@
 
 /*
 $Log$
+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
 
@@ -136,8 +139,10 @@ ClassImp(AliTRDgeometry)
   const Float_t AliTRDgeometry::fgkSeZpos  = -4.1525; 
   const Float_t AliTRDgeometry::fgkRaZpos  = -1.7425;
   const Float_t AliTRDgeometry::fgkPeZpos  =  0.0000;
-  const Float_t AliTRDgeometry::fgkMyZpos  =  0.6600;
-  const Float_t AliTRDgeometry::fgkDrZpos  =  2.1625;
+//const Float_t AliTRDgeometry::fgkMyZpos  =  0.6600;
+//const Float_t AliTRDgeometry::fgkDrZpos  =  2.1625;
+  const Float_t AliTRDgeometry::fgkMyZpos  =  0.8500;
+  const Float_t AliTRDgeometry::fgkDrZpos  =  2.3625;
   const Float_t AliTRDgeometry::fgkAmZpos  =  4.1125;
   const Float_t AliTRDgeometry::fgkCuZpos  = -1.3370; 
   const Float_t AliTRDgeometry::fgkSuZpos  =  0.0000;
@@ -205,10 +210,10 @@ void AliTRDgeometry::Init()
   //
 
   // The pad column (rphi-direction)  
-  SetColPadSize(1.0);
+  SetNColPad(96);
 
   // The time bucket
-  SetTimeBinSize(0.1);
+  SetNTimeBin(30);
 
   // The rotation matrix elements
   Float_t phi = 0;
@@ -228,30 +233,29 @@ void AliTRDgeometry::Init()
 }
 
 //_____________________________________________________________________________
-void AliTRDgeometry::SetColPadSize(Float_t size)
+void AliTRDgeometry::SetNColPad(Int_t npad)
 {
   //
-  // Redefines the pad size in column direction
+  // Redefines the number of pads in column direction
   //
 
-  fColPadSize = size;
   for (Int_t iplan = 0; iplan < fgkNplan; iplan++) {
-    fColMax[iplan] = 1 + TMath::Nint((fCwidth[iplan] - 2. * fgkCcthick) 
-                                                     / fColPadSize - 0.5);
-    fCol0[iplan]   = -fCwidth[iplan]/2. + fgkCcthick;
+    fColMax[iplan]     = npad;
+    fColPadSize[iplan] = (fCwidth[iplan] - 2. * fgkCcthick) / fColMax[iplan];
+    fCol0[iplan]       = -fCwidth[iplan]/2. + fgkCcthick;
   }
 
 }
 
 //_____________________________________________________________________________
-void AliTRDgeometry::SetTimeBinSize(Float_t size)
+void AliTRDgeometry::SetNTimeBin(Int_t nbin)
 {
   //
-  // Redefines the time bin size
+  // Redefines the number of time bins
   //
 
-  fTimeBinSize = size;
-  fTimeMax     = 1 + TMath::Nint(fgkDrThick / fTimeBinSize - 0.5);
+  fTimeMax     = nbin;
+  fTimeBinSize = fgkDrThick / ((Float_t) fTimeMax);
   for (Int_t iplan = 0; iplan < fgkNplan; iplan++) {
     fTime0[iplan]  = fgkRmin + fgkCcframe/2. + fgkDrZpos + 0.5 * fgkDrThick
                              + iplan * (fgkCheight + fgkCspace);
@@ -468,9 +472,9 @@ Bool_t AliTRDgeometry::Local2Global(Int_t iplan, Int_t icham, Int_t isect
   Float_t  rot[3];
 
   // calculate (x,y,z) position in rotated chamber
-  rot[0] = time0 + timeSlice * fTimeBinSize;
-  rot[1] = col0  + padCol    * fColPadSize;
-  rot[2] = row0  + padRow    * fRowPadSize;
+  rot[0] = time0 - timeSlice * fTimeBinSize;
+  rot[1] = col0  + padCol    * fColPadSize[iplan];
+  rot[2] = row0  + padRow    * fRowPadSize[iplan][icham][isect];
 
   // Rotate back to original position
   return RotateBack(idet,rot,global);

diff --git a/TRD/AliTRDgeometry.h b/TRD/AliTRDgeometry.h
index 80afb7749f8612d070c3aaf9929440c67d19d11d..ffa844b266844226a8dfde8f0d20288edcefacfa 100644 (file)
--- a/TRD/AliTRDgeometry.h
+++ b/TRD/AliTRDgeometry.h
@@ -45,9 +45,9 @@ class AliTRDgeometry : public AliGeometry {
   virtual void     SetPHOShole() = 0;
   virtual void     SetRICHhole() = 0;
 
-  virtual void     SetRowPadSize(Float_t size) {};
-  virtual void     SetColPadSize(Float_t size);
-  virtual void     SetTimeBinSize(Float_t size);
+  virtual void     SetNRowPad(Int_t p, Int_t c, Int_t npad) {};
+  virtual void     SetNColPad(Int_t npad);
+  virtual void     SetNTimeBin(Int_t nbin);
 
   virtual Bool_t   GetPHOShole() const = 0;
   virtual Bool_t   GetRICHhole() const = 0;
@@ -57,19 +57,19 @@ class AliTRDgeometry : public AliGeometry {
   virtual Int_t    GetChamber(Int_t d) const;
   virtual Int_t    GetSector(Int_t d)  const;
 
-  virtual Float_t  GetChamberWidth(Int_t p)             const { return fCwidth[p]; };
+  virtual Float_t  GetChamberWidth(Int_t p)                 const { return fCwidth[p]; };
    
-  virtual Int_t    GetRowMax(Int_t p, Int_t c, Int_t s) const { return fRowMax[p][c][s]; };
-  virtual Int_t    GetColMax(Int_t p)                   const { return fColMax[p];       };
-  virtual Int_t    GetTimeMax()                         const { return fTimeMax;         };
+  virtual Int_t    GetRowMax(Int_t p, Int_t c, Int_t s)     const { return fRowMax[p][c][s]; };
+  virtual Int_t    GetColMax(Int_t p)                       const { return fColMax[p];       };
+  virtual Int_t    GetTimeMax()                             const { return fTimeMax;         };
  
-  virtual Float_t  GetRow0(Int_t p, Int_t c, Int_t s)   const { return fRow0[p][c][s]; };
-  virtual Float_t  GetCol0(Int_t p)                     const { return fCol0[p];       };
-  virtual Float_t  GetTime0(Int_t p)                    const { return fTime0[p];      };
+  virtual Float_t  GetRow0(Int_t p, Int_t c, Int_t s)       const { return fRow0[p][c][s]; };
+  virtual Float_t  GetCol0(Int_t p)                         const { return fCol0[p];       };
+  virtual Float_t  GetTime0(Int_t p)                        const { return fTime0[p];      };
 
-  virtual Float_t  GetRowPadSize()                      const { return fRowPadSize;  };
-  virtual Float_t  GetColPadSize()                      const { return fColPadSize;  };
-  virtual Float_t  GetTimeBinSize()                     const { return fTimeBinSize; };
+  virtual Float_t  GetRowPadSize(Int_t p, Int_t c, Int_t s) const { return fRowPadSize[p][c][s]; };
+  virtual Float_t  GetColPadSize(Int_t p)                   const { return fColPadSize[p];       };
+  virtual Float_t  GetTimeBinSize()                         const { return fTimeBinSize;         };
 
   virtual void     GetGlobal(const AliRecPoint *p, TVector3 &pos, TMatrix &mat) const; 
   virtual void     GetGlobal(const AliRecPoint *p, TVector3 &pos) const;   
@@ -138,8 +138,8 @@ class AliTRDgeometry : public AliGeometry {
   Float_t              fCol0[kNplan];                       // Column-position of pad 0
   Float_t              fTime0[kNplan];                      // Time-position of pad 0
 
-  Float_t              fRowPadSize;                         // Pad size in z-direction
-  Float_t              fColPadSize;                         // Pad size in rphi-direction
+  Float_t              fRowPadSize[kNplan][kNcham][kNsect]; // Pad size in z-direction
+  Float_t              fColPadSize[kNplan];                 // Pad size in rphi-direction
   Float_t              fTimeBinSize;                        // Size of the time buckets
 
   Float_t              fRotA11[kNsect];                     // Matrix elements for the rotation
@@ -152,7 +152,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,2)                                // TRD geometry base class
+  ClassDef(AliTRDgeometry,3)                                // TRD geometry base class
 
 };
 

diff --git a/TRD/AliTRDgeometryFull.cxx b/TRD/AliTRDgeometryFull.cxx
index 6daca0fbea6b63dadc78435102194f6deb97a5cc..fe661b2edb4c5483c0ebec8c3155e31470973c13 100644 (file)
--- a/TRD/AliTRDgeometryFull.cxx
+++ b/TRD/AliTRDgeometryFull.cxx
@@ -15,6 +15,9 @@
 
 /*
 $Log$
+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
 
@@ -153,61 +156,95 @@ void AliTRDgeometryFull::Init()
   //                                             
 
   // The pad row (z-direction)
-  SetRowPadSize(4.5);
+  SetNRowPad();
 
 }
 
 //_____________________________________________________________________________
-void AliTRDgeometryFull::SetRowPadSize(Float_t size)
+void AliTRDgeometryFull::SetNRowPad(Int_t p, Int_t c, Int_t npad)
 {
   //
-  // Redefines the pad size in row direction
+  // Redefines the number of pads in raw direction for
+  // a given plane and chamber number
   //
 
-  fRowPadSize = size;
-
-  for (Int_t iplan = 0; iplan < fgkNplan; iplan++) {
-
-    for (Int_t isect = 0; isect < fgkNsect; isect++) {
-      Float_t clengthI = fClengthI[iplan];
-      Float_t clengthM = fClengthM1[iplan];
-      Float_t clengthO = fClengthO1[iplan];
-      switch (isect) {
-      case 12:
-      case 13:
-      case 14:
-      case 15:
-      case 16:
-        clengthM = fClengthM2[iplan];
-        clengthO = fClengthO2[iplan];
-        break;
-      case 4:
-      case 5:
-      case 6:
-        clengthO = fClengthO3[iplan];
-        break;
-      };
-      fRowMax[iplan][0][isect] = 1 + TMath::Nint((clengthO - 2. * fgkCcthick) 
-                                                           / fRowPadSize - 0.5);
-      fRowMax[iplan][1][isect] = 1 + TMath::Nint((clengthM - 2. * fgkCcthick) 
-                                                           / fRowPadSize - 0.5);
-      fRowMax[iplan][2][isect] = 1 + TMath::Nint((clengthI - 2. * fgkCcthick) 
-                                                           / fRowPadSize - 0.5);
-      fRowMax[iplan][3][isect] = 1 + TMath::Nint((clengthM - 2. * fgkCcthick) 
-                                                           / fRowPadSize - 0.5);
-      fRowMax[iplan][4][isect] = 1 + TMath::Nint((clengthO - 2. * fgkCcthick) 
-                                                           / fRowPadSize - 0.5);
-      fRow0[iplan][0][isect]   = -clengthI/2. - clengthM - clengthO + fgkCcthick; 
-      fRow0[iplan][1][isect]   = -clengthI/2. - clengthM            + fgkCcthick;
-      fRow0[iplan][2][isect]   = -clengthI/2.                       + fgkCcthick;
-      fRow0[iplan][3][isect]   =  clengthI/2.                       + fgkCcthick; 
-      fRow0[iplan][4][isect]   =  clengthI/2. + clengthM            + fgkCcthick; 
+  Float_t clengthI = fClengthI[p];
+  Float_t clengthM = fClengthM1[p];
+  Float_t clengthO = fClengthO1[p];
+  
+  for (Int_t iSect = 0; iSect < fgkNsect; iSect++) {
+
+    fRowMax[p][c][iSect] = npad;
+    if (c == 2) {
+      fRowPadSize[p][c][iSect] = (clengthI - 2. * fgkCcthick)
+                               / fRowMax[p][c][iSect];
+    }
+    if ((c == 1) || (c == 3)) {
+      fRowPadSize[p][c][iSect] = (clengthM - 2. * fgkCcthick)
+                               / fRowMax[p][c][iSect];
+    }
+    if ((c == 0) || (c == 4)) {
+      fRowPadSize[p][c][iSect] = (clengthO - 2. * fgkCcthick)
+                               / fRowMax[p][c][iSect];
     }
 
   }
 
 }
 
+//_____________________________________________________________________________
+void AliTRDgeometryFull::SetNRowPad()
+{
+  //
+  // Defines the number of pads in row direction
+  //
+
+  for (Int_t iPlan = 0; iPlan < fgkNplan; iPlan++) {
+
+    Float_t clengthI = fClengthI[iPlan];
+    Float_t clengthM = fClengthM1[iPlan];
+    Float_t clengthO = fClengthO1[iPlan];
+
+    for (Int_t iSect = 0; iSect < fgkNsect; iSect++) {
+
+      fRow0[iPlan][0][iSect]   = -clengthI/2. - clengthM - clengthO + fgkCcthick; 
+      fRow0[iPlan][1][iSect]   = -clengthI/2. - clengthM            + fgkCcthick;
+      fRow0[iPlan][2][iSect]   = -clengthI/2.                       + fgkCcthick;
+      fRow0[iPlan][3][iSect]   =  clengthI/2.                       + fgkCcthick; 
+      fRow0[iPlan][4][iSect]   =  clengthI/2. + clengthM            + fgkCcthick; 
+
+      for (Int_t iCham = 0; iCham < fgkNcham; iCham++) {
+
+        if (iCham == 2) {
+          fRowMax[iPlan][iCham][iSect]     = 18;
+          fRowPadSize[iPlan][iCham][iSect] = (clengthI - 2. * fgkCcthick)
+                                           / fRowMax[iPlan][iCham][iSect];
+        }
+        if ((iCham == 1) || (iCham == 3)) {
+          fRowMax[iPlan][iCham][iSect]     = 24;
+          fRowPadSize[iPlan][iCham][iSect] = (clengthM - 2. * fgkCcthick)
+                                           / fRowMax[iPlan][iCham][iSect];
+        }
+        if ((iCham == 0) || (iCham == 4)) {
+          if (iPlan <  4) {
+            fRowMax[iPlan][iCham][iSect] = 24;
+          }
+          if (iPlan == 4) {
+            fRowMax[iPlan][iCham][iSect] = 22;
+          }
+          if (iPlan == 5) {
+            fRowMax[iPlan][iCham][iSect] = 20;
+          }
+          fRowPadSize[iPlan][iCham][iSect] = (clengthO - 2. * fgkCcthick)
+                                           / fRowMax[iPlan][iCham][iSect];
+        }
+
+      }
+    }
+  }
+
+}
+
 //_____________________________________________________________________________
 void AliTRDgeometryFull::CreateGeometry(Int_t *idtmed)
 {

diff --git a/TRD/AliTRDgeometryFull.h b/TRD/AliTRDgeometryFull.h
index 77709bba40d6543f016065da52ab71d6f62f1eb7..da9e6164c4cb7a12dbbc20d78ea584e06e44ba65 100644 (file)
--- a/TRD/AliTRDgeometryFull.h
+++ b/TRD/AliTRDgeometryFull.h
@@ -21,7 +21,8 @@ class AliTRDgeometryFull : public AliTRDgeometry {
           void    SetPHOShole()       { fPHOShole = kTRUE; };
           void    SetRICHhole()       { fRICHhole = kTRUE; };
 
-  virtual void    SetRowPadSize(Float_t size);
+          void    SetNRowPad();
+  virtual void    SetNRowPad(Int_t p, Int_t c, Int_t npad);
 
           Bool_t  GetPHOShole() const { return fPHOShole;  };
           Bool_t  GetRICHhole() const { return fRICHhole;  };

diff --git a/TRD/AliTRDgeometryHole.cxx b/TRD/AliTRDgeometryHole.cxx
index 83760496eeffa9de33866df6380eab9f76e35792..1de25b18b52387fc59dcdd7078125b84ffe33244 100644 (file)
--- a/TRD/AliTRDgeometryHole.cxx
+++ b/TRD/AliTRDgeometryHole.cxx
@@ -15,6 +15,9 @@
 
 /*
 $Log$
+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
 
@@ -141,57 +144,91 @@ void AliTRDgeometryHole::Init()
   //                                             
 
   // The pad row (z-direction)
-  SetRowPadSize(4.5);
+  SetNRowPad();
 
 }
 
 //_____________________________________________________________________________
-void AliTRDgeometryHole::SetRowPadSize(Float_t size)
+void AliTRDgeometryHole::SetNRowPad(Int_t p, Int_t c, Int_t npad)
 {
   //
-  // Redefines the pad size in row direction
+  // Redefines the number of pads in raw direction for
+  // a given plane and chamber number
   //
 
-  fRowPadSize = size;
-
-  for (Int_t iplan = 0; iplan < fgkNplan; iplan++) {
-
-    for (Int_t isect = 0; isect < fgkNsect; isect++) {
-      Float_t clengthI = fClengthI[iplan];
-      Float_t clengthM = fClengthM1[iplan];
-      Float_t clengthO = fClengthO1[iplan];
-      switch (isect) {
-      case 12:
-      case 13:
-      case 14:
-      case 15:
-      case 16:
-        clengthM = fClengthM2[iplan];
-        clengthO = fClengthO2[iplan];
-        break;
-      case 4:
-      case 5:
-      case 6:
-        clengthO = fClengthO3[iplan];
-        break;
-      };
-      fRowMax[iplan][0][isect] = 1 + TMath::Nint((clengthO - 2. * fgkCcthick) 
-                                                           / fRowPadSize - 0.5);
-      fRowMax[iplan][1][isect] = 1 + TMath::Nint((clengthM - 2. * fgkCcthick) 
-                                                           / fRowPadSize - 0.5);
-      fRowMax[iplan][2][isect] = 1 + TMath::Nint((clengthI - 2. * fgkCcthick) 
-                                                           / fRowPadSize - 0.5);
-      fRowMax[iplan][3][isect] = 1 + TMath::Nint((clengthM - 2. * fgkCcthick) 
-                                                           / fRowPadSize - 0.5);
-      fRowMax[iplan][4][isect] = 1 + TMath::Nint((clengthO - 2. * fgkCcthick) 
-                                                           / fRowPadSize - 0.5);
-      fRow0[iplan][0][isect]   = -clengthI/2. - clengthM - clengthO + fgkCcthick; 
-      fRow0[iplan][1][isect]   = -clengthI/2. - clengthM            + fgkCcthick;
-      fRow0[iplan][2][isect]   = -clengthI/2.                       + fgkCcthick;
-      fRow0[iplan][3][isect]   =  clengthI/2.                       + fgkCcthick; 
-      fRow0[iplan][4][isect]   =  clengthI/2. + clengthM            + fgkCcthick; 
+  Float_t clengthI = fClengthI[p];
+  Float_t clengthM = fClengthM1[p];
+  Float_t clengthO = fClengthO1[p];
+  
+  for (Int_t iSect = 0; iSect < fgkNsect; iSect++) {
+
+    fRowMax[p][c][iSect] = npad;
+    if (c == 2) {
+      fRowPadSize[p][c][iSect] = (clengthI - 2. * fgkCcthick)
+                               / fRowMax[p][c][iSect];
+    }
+    if ((c == 1) || (c == 3)) {
+      fRowPadSize[p][c][iSect] = (clengthM - 2. * fgkCcthick)
+                               / fRowMax[p][c][iSect];
     }
+    if ((c == 0) || (c == 4)) {
+      fRowPadSize[p][c][iSect] = (clengthO - 2. * fgkCcthick)
+                               / fRowMax[p][c][iSect];
+    }
+
+  }
 
+}
+
+//_____________________________________________________________________________
+void AliTRDgeometryHole::SetNRowPad()
+{
+  //
+  // Defines the pad size in row direction
+  //
+
+  for (Int_t iPlan = 0; iPlan < fgkNplan; iPlan++) {
+
+    Float_t clengthI = fClengthI[iPlan];
+    Float_t clengthM = fClengthM1[iPlan];
+    Float_t clengthO = fClengthO1[iPlan];
+
+    for (Int_t iSect = 0; iSect < fgkNsect; iSect++) {
+
+      fRow0[iPlan][0][iSect]   = -clengthI/2. - clengthM - clengthO + fgkCcthick; 
+      fRow0[iPlan][1][iSect]   = -clengthI/2. - clengthM            + fgkCcthick;
+      fRow0[iPlan][2][iSect]   = -clengthI/2.                       + fgkCcthick;
+      fRow0[iPlan][3][iSect]   =  clengthI/2.                       + fgkCcthick; 
+      fRow0[iPlan][4][iSect]   =  clengthI/2. + clengthM            + fgkCcthick; 
+
+      for (Int_t iCham = 0; iCham < fgkNcham; iCham++) {
+
+        if (iCham == 2) {
+          fRowMax[iPlan][iCham][iSect] = 18;
+          fRowPadSize[iPlan][iCham][iSect] = (clengthI - 2. * fgkCcthick)
+                                           / fRowMax[iPlan][iCham][iSect];
+        }
+        if ((iCham == 1) || (iCham == 3)) {
+          fRowMax[iPlan][iCham][iSect] = 24;
+          fRowPadSize[iPlan][iCham][iSect] = (clengthM - 2. * fgkCcthick)
+                                           / fRowMax[iPlan][iCham][iSect];
+        }
+        if ((iCham == 0) || (iCham == 4)) {
+          if (iPlan <  4) {
+            fRowMax[iPlan][iCham][iSect] = 24;
+          }
+          if (iPlan == 4) {
+            fRowMax[iPlan][iCham][iSect] = 22;
+          }
+          if (iPlan == 5) {
+            fRowMax[iPlan][iCham][iSect] = 20;
+          }
+          fRowPadSize[iPlan][iCham][iSect] = (clengthO - 2. * fgkCcthick)
+                                           / fRowMax[iPlan][iCham][iSect];
+        }
+
+      }
+    }
   }
 
 }

diff --git a/TRD/AliTRDgeometryHole.h b/TRD/AliTRDgeometryHole.h
index dba38f2ccb9647dba9a6fb0183891759b875acd3..93f885903e617b26f4f4233362cc8910c62f7a4f 100644 (file)
--- a/TRD/AliTRDgeometryHole.h
+++ b/TRD/AliTRDgeometryHole.h
@@ -21,7 +21,8 @@ class AliTRDgeometryHole : public AliTRDgeometry {
           void    SetPHOShole()       { };
           void    SetRICHhole()       { };
 
-  virtual void    SetRowPadSize(Float_t size);
+          void    SetNRowPad();
+  virtual void    SetNRowPad(Int_t p, Int_t c, Int_t npad);
 
           Bool_t  GetPHOShole() const { return kTRUE; };
           Bool_t  GetRICHhole() const { return kTRUE; };

diff --git a/TRD/AliTRDrecPoint.cxx b/TRD/AliTRDrecPoint.cxx
index 6146ac3a9856ebbb9f4bf691d08ef4f3d14d5330..d46fa75023a6ad7ef423c92b58435f811e35269f 100644 (file)
--- a/TRD/AliTRDrecPoint.cxx
+++ b/TRD/AliTRDrecPoint.cxx
@@ -15,6 +15,9 @@
 
 /*
 $Log$
+Revision 1.5  2000/11/14 14:40:27  cblume
+Correction for the Sun compiler (kTRUE and kFALSE)
+
 Revision 1.4  2000/11/01 14:53:21  cblume
 Merge with TRD-develop
 
@@ -126,7 +129,12 @@ void AliTRDrecPoint::SetLocalPosition(TVector3 &pos)
   // row:  pad-size / sqrt(12)
   // col:  not defined yet
   // time: bin-size / sqrt(12)
-  fLocPosM->operator()(0,0) = ((AliTRDgeometry *) fGeom)->GetRowPadSize()  
+  Int_t plane   = ((AliTRDgeometry *) fGeom)->GetPlane(fDetector);
+  Int_t chamber = ((AliTRDgeometry *) fGeom)->GetChamber(fDetector);
+  Int_t sector  = ((AliTRDgeometry *) fGeom)->GetSector(fDetector);
+  fLocPosM->operator()(0,0) = ((AliTRDgeometry *) fGeom)->GetRowPadSize(plane
+                                                                       ,chamber
+                                                                       ,sector) 
                             / kSq12;
   fLocPosM->operator()(1,1) = 0.0;
   fLocPosM->operator()(2,2) = ((AliTRDgeometry *) fGeom)->GetTimeBinSize() 
@@ -160,17 +168,20 @@ void AliTRDrecPoint::SetTrackingYZ(Float_t sigmaY, Float_t sigmaZ)
 
   //  Float_t   offset = 0.5 * ((AliTRDgeometry *) fGeom)->GetChamberWidth(plane);
 
-  fY = - (col0 + padCol * ((AliTRDgeometry *) fGeom)->GetColPadSize());
-
-  fZ = row0  + padRow * ((AliTRDgeometry *) fGeom)->GetRowPadSize();
+  fY = - (col0 + padCol * ((AliTRDgeometry *) fGeom)->GetColPadSize(plane));
+  fZ =    row0 + padRow * ((AliTRDgeometry *) fGeom)->GetRowPadSize(plane
+                                                                   ,chamber
+                                                                   ,sector);
 
   //  fSigmaY = sigmaY * sigmaY;
   //  fSigmaZ = sigmaZ * sigmaZ;
 
   fSigmaY2 = 0.05 * 0.05;
 
-  fSigmaZ2 = ((AliTRDgeometry *) fGeom)->GetRowPadSize() *
-             ((AliTRDgeometry *) fGeom)->GetRowPadSize() / 12.;
+  fSigmaZ2 = ((AliTRDgeometry *) fGeom)->GetRowPadSize(plane,chamber,sector)
+           * ((AliTRDgeometry *) fGeom)->GetRowPadSize(plane,chamber,sector) 
+           / 12.;
+
 }                                    
 
 //_____________________________________________________________________________

diff --git a/TRD/AliTRDtracker.cxx b/TRD/AliTRDtracker.cxx
index 00868663a762ab635182745aff576d9a531cd4cb..7b6739588215f4719006bc47465a8dca370b18fd 100644 (file)
--- a/TRD/AliTRDtracker.cxx
+++ b/TRD/AliTRDtracker.cxx
@@ -15,6 +15,9 @@
                                                       
 /*
 $Log$
+Revision 1.8  2000/12/20 13:00:44  cblume
+Modifications for the HP-compiler
+
 Revision 1.7  2000/12/08 16:07:02  cblume
 Update of the tracking by Sergei
 
@@ -154,7 +157,9 @@ Double_t AliTRDtracker::ExpectedSigmaZ2(Double_t r, Double_t tgl)
 {
   // Parametrised "expected" error of the cluster reconstruction in Z 
 
-  Double_t s, pad = fGeom->GetRowPadSize();
+  // Take an example pad size for the time being, check back
+  // again with Sergei
+  Double_t s, pad = fGeom->GetRowPadSize(0,2,0);
   s = pad * pad /12.;  
   return s;
 }