/*
$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
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
/*
$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
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;
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) {
// 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)) {
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"
/*
$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
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;
//
// 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;
}
//_____________________________________________________________________________
-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);
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);
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;
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;
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
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
};
/*
$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
//
// 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)
{
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; };
/*
$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
//
// 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];
+ }
+
+ }
+ }
}
}
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; };
/*
$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
// 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()
// 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.;
+
}
//_____________________________________________________________________________
/*
$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
{
// 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;
}