* about the suitability of this software for any purpose. It is *
* provided "as is" without express or implied warranty. *
**************************************************************************/
+/*
+$Log$
+Revision 1.15 2001/05/16 14:57:16 alibrary
+New files for folders and Stack
+
+Revision 1.14 2001/05/14 06:21:49 barbera
+Some unuseful printout commented
+
+Revision 1.13 2001/05/14 05:44:11 barbera
+Version 1.11 reput in place to avoid problem with reconstruction
+
+Revision 1.11 2001/05/03 16:12:37 nilsen
+Fixed up LocalToDet, DetToLocal, GetCrossing, GetPadTxz to work with different
+angles in layer 5 and 6.
+
+Revision 1.10 2001/05/01 22:42:22 nilsen
+Update of SSD simulation and reconstruction code by Boris and Enrico.
+
+Revision 1.9 2001/04/27 14:16:50 nilsen
+Remove dead and/or unused code and printout lines. i.e. cleaned it up a bit.
+
+*/
#include <TMath.h>
#include <TF1.h>
-#include <iostream.h>
+#include <Riostream.h>
#include "AliITSsegmentationSSD.h"
#include "AliITSgeom.h"
-
+#include "AliRun.h"
+#include "AliModule.h"
ClassImp(AliITSsegmentationSSD)
AliITSsegmentationSSD::AliITSsegmentationSSD(){
- // default constructor
- fGeom=0;
- fCorr=0;
+ // default constructor
+ fGeom = 0;
+ fCorr = 0;
+ fLayer = 0;
}
-//------------------------------
+//----------------------------------------------------------------------
AliITSsegmentationSSD::AliITSsegmentationSSD(AliITSgeom *geom){
- // constuctor
- fGeom=geom;
- fCorr=0;
- SetDetSize();
- cout<<"Dx="<<fDx<<endl;
- SetPadSize();
- SetNPads();
- Init();
-
+ // constuctor
+ fGeom = geom;
+ fCorr = 0;
+ SetDetSize();
+ SetPadSize();
+ SetNPads();
+ SetAngles();
+ fLayer = 0;
}
-//____________________________________________________________________________
-AliITSsegmentationSSD& AliITSsegmentationSSD::operator=(AliITSsegmentationSSD &source){
+//______________________________________________________________________
+AliITSsegmentationSSD& AliITSsegmentationSSD::operator=(
+ AliITSsegmentationSSD &source){
// Operator =
- if(this==&source) return *this;
- this->fNstrips = source.fNstrips;
- this->fStereoP = source.fStereoP;
- this->fStereoN = source.fStereoN;
- this->fPitch = source.fPitch;
- this->fDz = source.fDz;
- this->fDx = source.fDx;
- this->fDy = source.fDy;
- this->fGeom = source.fGeom; // copy only the pointer
- this->fCorr = new TF1(*(source.fCorr)); // make a proper copy
- return *this;
-
+ if(this==&source) return *this;
+ this->fNstrips = source.fNstrips;
+ this->fStereoP = source.fStereoP;
+ this->fStereoN = source.fStereoN;
+ this->fStereoPl5 = source.fStereoPl5;
+ this->fStereoNl5 = source.fStereoNl5;
+ this->fStereoPl6 = source.fStereoPl6;
+ this->fStereoNl6 = source.fStereoNl6;
+ this->fLayer = source.fLayer;
+ this->fPitch = source.fPitch;
+ this->fDz = source.fDz;
+ this->fDx = source.fDx;
+ this->fDy = source.fDy;
+ this->fLayer = source.fLayer;
+ this->fGeom = source.fGeom; // copy only the pointer
+ this->fCorr = new TF1(*(source.fCorr)); // make a proper copy
+ return *this;
}
-//____________________________________________________________________________
+//______________________________________________________________________
AliITSsegmentationSSD::AliITSsegmentationSSD(AliITSsegmentationSSD &source){
- // copy constructor
- *this = source;
+ // copy constructor
+ *this = source;
}
-//------------------------------
+//----------------------------------------------------------------------
void AliITSsegmentationSSD::Init(){
- // standard initalizer
+ // standard initalizer
- //AliITSgeomSSD *gssd = (AliITSgeomSSD *) (fGeom->GetShape(5,1,1));
- //const Float_t kconv=10000.;
- /*
- fDx = 2.*kconv*gssd->GetDx();
- fDz = 2.*kconv*gssd->GetDz();
- fDy = 2.*kconv*gssd->GetDy();
- */
SetPadSize();
SetNPads();
SetAngles();
+}
+//----------------------------------------------------------------------
+void AliITSsegmentationSSD::Angles(Float_t &aP,Float_t &aN){
+ if (fLayer == 5){
+ aP = fStereoPl5;
+ aN = fStereoNl5;
+ } // end if
+ if (fLayer == 6){
+ aP = fStereoPl6;
+ aN = fStereoNl6;
+ } // end if
}
-//-------------------------------------------------------
+//----------------------------------------------------------------------
+void AliITSsegmentationSSD::SetLayer(Int_t l){
+
+ if (l==5) fLayer =5;
+ if (l==6) fLayer =6;
+}
+//----------------------------------------------------------------------
void AliITSsegmentationSSD::GetPadTxz(Float_t &x,Float_t &z){
- // returns P and N sided strip numbers for a given location.
+ // returns P and N sided strip numbers for a given location.
// Transformation from microns detector center local coordinates
// to detector P and N side strip numbers..
/* _- Z
|00/
|0/
// expects x, z in microns
-
- Float_t tanP=TMath::Tan(fStereoP);
- Float_t tanN=TMath::Tan(-fStereoN);
+ */
+ Float_t StereoP, StereoN;
+ Angles(StereoP,StereoN);
+ Float_t tanP = TMath::Tan(StereoP);
+ Float_t tanN = TMath::Tan(-StereoN);
Float_t x1 = x;
Float_t z1 = z;
x1 += fDx/2;
z1 += fDz/2;
- x = (x1 - z1*tanP)/fPitch;
- z = (x1 - tanN*(z1 - fDz))/fPitch;
+ x = (x1 - z1*tanP)/fPitch;
+ z = (x1 - tanN*(z1 - fDz))/fPitch;
}
-//-------------------------------------------------------
-void AliITSsegmentationSSD::GetPadIxz(Float_t x,Float_t z,Int_t &iP,Int_t &iN)
-{
+//----------------------------------------------------------------------
+void AliITSsegmentationSSD::GetPadIxz(Float_t x,Float_t z,Int_t &iP,Int_t &iN){
// returns P and N sided strip numbers for a given location.
/* _- Z
+ angle / ^
|0/
// expects x, z in microns
-/*
- Float_t tanP=TMath::Tan(fStereoP);
- Float_t tanN=TMath::Tan(fStereoN);
- //cout<<"1 segment::GetPad: xL,zL,fDx,fDz ="<<x<<","<<z<<","<<fDx<<","<<fDz<<endl;
- //cout<<"2 segment: ? tanP,tanN ="<<tanP<<","<<tanN<<endl;
- tanP = 0.0075;
- tanN = 0.0275;
+ */
+
+ Float_t StereoP, StereoN;
+ Angles(StereoP,StereoN);
+ Float_t tanP=TMath::Tan(StereoP);
+ Float_t tanN=TMath::Tan(StereoN);
Float_t x1=x,z1=z;
-// cout << "GetPadIxz::Tan(" << fStereoP << ")=" << tanP << endl;
-// cout << "GetPadIxz::Tan(" << fStereoN << ")=" << tanN << endl;
x1 += fDx/2;
z1 += fDz/2;
Float_t ldX = x1 - z1*tanP; // distance from left-down edge
-*/
- this->GetPadTxz(x,z); // use existing routine.
- iP = (Int_t) x; //(Int_t)(ldX/fPitch);
+ iP = (Int_t)(ldX/fPitch);
iP = (iP<0)? -1: iP;
iP = (iP>fNstrips)? -1: iP;
-/*
- //cout<<"3 segment::GetPad: x1,tanP,ix1 ="<<ldX<<","<<tanP<<","<<iP<<endl;
ldX = x1 - tanN*(fDz - z1);
-*/
- iN = (Int_t) z; //(Int_t)(ldX/fPitch);
+ iN = (Int_t)(ldX/fPitch);
iN = (iN<0)? -1: iN;
iN = (iN>fNstrips)? -1: iN;
- //cout<<"4 segment::GetPad: x2,tanN,ix2 ="<<ldX<<","<<tanN<<","<<iN<<endl;
-
}
//-------------------------------------------------------
-void AliITSsegmentationSSD::GetPadCxz(Int_t iP,Int_t iN,Float_t &x,Float_t &z)
-{
- // actually this is the GetCrossing(Float_t &,Float_t &)
-
- // returns x, z in microns !
-
- Float_t flag=2*fDx;
-
- Float_t tanP=TMath::Tan(fStereoP);
- Float_t tanN=TMath::Tan(fStereoN);
+void AliITSsegmentationSSD::GetPadCxz(Int_t iP,Int_t iN,Float_t &x,Float_t &z){
+ // actually this is the GetCrossing(Float_t &,Float_t &)
+ // returns local x, z in microns !
- Float_t dx = 0.1;
-// cout << "GetPadCxz::Tan(" << fStereoP << ")=" << tanP << endl;
-// cout << "GetPadCxz::Tan(" << fStereoN << ")=" << tanN << endl;
-// cout << "GetPadCxz::dx=" << dx << endl;
- x = iP*fPitch;
- z = iN*fPitch;
+ Float_t Dx = fDx; // detector size in x direction, microns
+ Float_t Dz = fDz; // detector size in z direction, microns
+ Float_t xP; // x coordinate in the P side from the first P strip
+ Float_t xN; // x coordinate in the N side from the first N strip
+ Float_t StereoP, StereoN;
+ Angles(StereoP,StereoN);
+ Float_t kP=TMath::Tan(StereoP);
+ Float_t kN=TMath::Tan(StereoN);
- if(tanP + tanN == 0) {x=z=flag; return ;}
-
- z = (z - x + tanN * fDz) / (tanP + tanN);
- x = x + tanP * z;
-
- x -= fDx/2;
- z -= fDz/2;
-
- if ( ( z < -(fDz/2+dx) ) || ( z > (fDz/2+dx) ) ) {x=z=flag; return ;}
- if ( ( x < -(fDx/2+dx) ) || ( x > (fDx/2+dx) ) ) {x=z=flag; return ;}
+ xP=iP*fPitch;
+ xN=iN*fPitch;
+ x = xP + kP*(Dz*kN-xP+xN)/(kP+kN);
+ z = (Dz*kN-xP+xN)/(kP+kN);
+ x -= Dx/2;
+ z -= Dz/2;
+ //if(TMath::Abs(z) > Dz/2) cout<<"Warning, wrong z local ="<<z<<endl;
+ // Check that zL is inside the detector for the
+ // correspondent xP and xN coordinates
return;
}
const Double_t kconst = 1.0E-04; // convert microns to cm.
Float_t flag=kconst*Dx(); // error value
Double_t th=0.0,dx,dz,i,a,b=0.0,xb[4],zb[4];
+ Float_t StereoP, StereoN;
+ Angles(StereoP,StereoN);
z = 0.0; // Strip center in z.
if(iPN<0 || iPN>1){// if error return full detector size in x.
- x = z = flag; return;
+ x = z = flag;
+ return;
+ } // end if
+ if(ix<0 || ix>=fNstrips) { // if error return full detector size in x.
+ x = z = flag;
+ return;
} // end if
- if(ix<0 || ix>=fNstrips) {x = z = flag; return;} // if error return full
- // detector size in x.
i = (Double_t) ix; // convert to double
dx = 0.5*kconst*Dx(); // half distance in x in cm
dz = 0.5*kconst*Dz(); // half distance in z in cm
a = kconst*Dpx(ix)*(i+0.5)-dx; // Min x value.
if(iPN==0){ //P-side angle defined backwards.
- th = TMath::Tan(fStereoP);
+ th = TMath::Tan(StereoP);
b = dz*th;
}else if(iPN==1){ // N-side
- th = TMath::Tan(-fStereoN);
+ th = TMath::Tan(-StereoN);
b = -dz*th;
} // end if
// compute average/center position of the strip.
xb[3] = a+b-dz*th; zb[3] = -dz;
x = 0.0; z = 0.0;
for(Int_t j=0;j<4;j++){
-// cout << "xb["<<j<<"]="<<xb[j]<<" zb["<<j<<"[="<<zb[j]<<endl;
if(xb[j]>=-dx && xb[j]<=dx && zb[j]>=-dz && zb[j]<=dz){
x += xb[j];
z += zb[j];
*/
const Double_t kconst = 1.0E-04; // convert microns to cm.
Double_t thp,thn,th,dx,dz,p,ip,in;
-
+ Float_t StereoP, StereoN;
+ Angles(StereoP,StereoN);
- thp = TMath::Tan(fStereoP);
- thn = TMath::Tan(-fStereoN);
+ thp = TMath::Tan(StereoP);
+ thn = TMath::Tan(-StereoN);
th = thp-thn;
if(th==0.0) { // parall strips then never cross.
x = 0.0;
in = (Double_t) iN; // convert to double now for speed
dx = 0.5*kconst*Dx(); // half distance in x in cm
dz = 0.5*kconst*Dz(); // half distance in z in cm
- p = kconst*Dpx(iP); // Get strip spacing/pitch now
+ p = kconst*Dpx(iP); // Get strip spacing/pitch now
x = 0.5*p+dx + (p*(in*thp-ip*thn)-2.0*dz*thp*thn)/th;
z =(p*(in-ip)-dz*(thp+thn))/th;
// compute correlations.
c[0][0] = -thn*p/th; // dx/diP
- c[1][1] = p/th; // dz/diN
- c[0][1] = p*thp/th; // dx/diN
- c[1][0] = -p/th; // dz/diP
+ c[1][1] = p/th; // dz/diN
+ c[0][1] = p*thp/th; // dx/diN
+ c[1][0] = -p/th; // dz/diP
if(x<-dx || x>dx || z<-dz || z>dz) return kFALSE; // crossing is outside
// of the detector so
// these strips don't
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff