X-Git-Url: http://git.uio.no/git/?a=blobdiff_plain;f=ITS%2FAliITSsegmentationSDD.cxx;h=b870e79854b5152e57938b24132f4529439e5fb5;hb=31f11c63e553375404a7821eea8d4076e813ec2d;hp=0d4cceff60729f92bcd729014353601b056a811a;hpb=f5d698b9b11fde9fdb09253da58aa4bd78ec0646;p=u%2Fmrichter%2FAliRoot.git diff --git a/ITS/AliITSsegmentationSDD.cxx b/ITS/AliITSsegmentationSDD.cxx index 0d4cceff607..b870e79854b 100644 --- a/ITS/AliITSsegmentationSDD.cxx +++ b/ITS/AliITSsegmentationSDD.cxx @@ -12,82 +12,127 @@ * about the suitability of this software for any purpose. It is * * provided "as is" without express or implied warranty. * **************************************************************************/ - -#include +#include #include - +#include +#include +#include #include "AliITSsegmentationSDD.h" -#include "AliITS.h" -#include "AliITSgeom.h" -#include "AliITSgeomSDD.h" -#include "AliRun.h" -#include "AliITSresponse.h" +#include "AliITSDriftSpeedSDD.h" + +///////////////////////////////////////////////////////////////////////////// +// Segmentation class for drift detectors // +// // +// microcables microcables // +// /\ /\ // +// || || // +// || || // +// || || // +// 0 256 0 // +// 0 |----------------------|---------------------| 511 // +// | time-bins | time-bins | // +// | a | a | // +// | n | n | // +// X <_|_o____________________|___________________o_|__ // +// | d | d | // +// | e LEFT SIDE | RIGHT SIDE e | // +// | s CHANNEL 0 | CHANNEL 1 s | // +// | Xlocal > 0 | Xlocal < 0 | // +// 255 |----------------------|---------------------| 256 // +// | // +// | // +// V // +// Z // +///////////////////////////////////////////////////////////////////////////// + +/* $Id$ */ +const Float_t AliITSsegmentationSDD::fgkDxDefault = 35085.; +const Float_t AliITSsegmentationSDD::fgkDzDefault = 75264.; +const Float_t AliITSsegmentationSDD::fgkDyDefault = 300.; +const Float_t AliITSsegmentationSDD::fgkPitchDefault = 294.; +const Float_t AliITSsegmentationSDD::fgkClockDefault = 40.; +const Int_t AliITSsegmentationSDD::fgkHalfNanodesDefault = 256; +const Int_t AliITSsegmentationSDD::fgkNsamplesDefault = 256; +const Int_t AliITSsegmentationSDD::fgkNchipsPerHybrid = 4; +const Int_t AliITSsegmentationSDD::fgkNanodesPerChip = 64; +const Float_t AliITSsegmentationSDD::fgkCm2Micron = 10000.; +const Float_t AliITSsegmentationSDD::fgkMicron2Cm = 1.0E-04; ClassImp(AliITSsegmentationSDD) -//---------------------------------------------------------------------- -AliITSsegmentationSDD::AliITSsegmentationSDD(AliITSgeom* geom, - AliITSresponse *resp){ - // constructor - fGeom=geom; - fResponse=resp; - fCorr=0; - SetDetSize(); - SetPadSize(); - SetNPads(); -} //______________________________________________________________________ -AliITSsegmentationSDD::AliITSsegmentationSDD(){ - // standard constructor - fGeom=0; - fResponse=0; - fCorr=0; - SetDetSize(); - SetPadSize(); - SetNPads(); - +AliITSsegmentationSDD::AliITSsegmentationSDD(Option_t *opt) : AliITSsegmentation(), +fNsamples(0), +fNanodes(0), +fPitch(0), +fTimeStep(0), +fDriftSpeed(0), +fSetDriftSpeed(0){ + // Default constructor + Init(); + if(strstr(opt,"TGeo")){ + if(!gGeoManager){ + AliError("Geometry is not initialized\n"); + return; + } + TGeoVolume *v=NULL; + v = gGeoManager->GetVolume("ITSsddSensitivL3"); + if(!v){ + AliWarning("TGeo volume ITSsddSensitivL3 not found (hint: use v11Hybrid geometry)\n Using hardwired default values"); + } + else { + TGeoBBox *s=(TGeoBBox*)v->GetShape(); + SetDetSize(s->GetDX()*10000.,s->GetDZ()*20000.,s->GetDY()*20000.); + } + } } + //______________________________________________________________________ -AliITSsegmentationSDD& AliITSsegmentationSDD::operator=(AliITSsegmentationSDD - &source){ - // Operator = - if(this==&source) return *this; - this->fNsamples = source.fNsamples; - this->fNanodes = source.fNanodes; - this->fPitch = source.fPitch; - this->fTimeStep = source.fTimeStep; - this->fDx = source.fDx; - this->fDz = source.fDz; - this->fDy = source.fDy; - this->fCorr = new TF1(*(source.fCorr)); - this->fGeom = source.fGeom; // Just copy the pointer - this->fResponse = source.fResponse; //Just copy the pointer - return *this; +void AliITSsegmentationSDD::Copy(TObject &obj) const { + // protected method. copy this to obj + AliITSsegmentation::Copy(obj); + ((AliITSsegmentationSDD& ) obj).fNsamples = fNsamples; + ((AliITSsegmentationSDD& ) obj).fNanodes = fNanodes; + ((AliITSsegmentationSDD& ) obj).fPitch = fPitch; + ((AliITSsegmentationSDD& ) obj).fTimeStep = fTimeStep; + ((AliITSsegmentationSDD& ) obj).fDriftSpeed = fDriftSpeed; + ((AliITSsegmentationSDD& ) obj).fSetDriftSpeed = fSetDriftSpeed; } + //______________________________________________________________________ -AliITSsegmentationSDD::AliITSsegmentationSDD(AliITSsegmentationSDD &source){ - // Copy constructor - *this = source; +AliITSsegmentationSDD& AliITSsegmentationSDD::operator=(const AliITSsegmentationSDD &source){ + // = operator + if(this==&source) return *this; + source.Copy(*this); + return *this; } -//---------------------------------------------------------------------- -void AliITSsegmentationSDD::Init(){ - // Standard initilisation routine - if(!fGeom) { - return; - //fGeom = ((AliITS*)gAlice->GetModule("ITS"))->GetITSgeom(); - } - AliITSgeomSDD *gsdd = (AliITSgeomSDD *) (fGeom->GetShape(3,1,1)); +//____________________________________________________________________________ +AliITSsegmentationSDD::AliITSsegmentationSDD(const AliITSsegmentationSDD &source) : + AliITSsegmentation(source), +fNsamples(0), +fNanodes(0), +fPitch(0), +fTimeStep(0), +fDriftSpeed(0), +fSetDriftSpeed(0){ + // copy constructor + source.Copy(*this); +} - const Float_t kconv=10000.; - fDz = 2.*kconv*gsdd->GetDz(); - fDx = kconv*gsdd->GetDx(); - fDy = 2.*kconv*gsdd->GetDy(); +//---------------------------------------------------------------------- +void AliITSsegmentationSDD::Init(){ +// Standard initilisation routine + fDriftSpeed=AliITSDriftSpeedSDD::DefaultDriftSpeed(); + fCorr=0; + SetDetSize(fgkDxDefault,fgkDzDefault,fgkDyDefault); + SetPadSize(fgkPitchDefault,fgkClockDefault); + SetNPads(fgkHalfNanodesDefault,fgkNsamplesDefault); } //---------------------------------------------------------------------- void AliITSsegmentationSDD:: -Neighbours(Int_t iX, Int_t iZ, Int_t* Nlist, Int_t Xlist[8], Int_t Zlist[8]){ +Neighbours(Int_t iX, Int_t iZ, Int_t* Nlist, Int_t Xlist[8], Int_t Zlist[8]) const { // returns neighbours for use in Cluster Finder routines and the like if(iX >= fNanodes) printf("iX > fNanodes %d %d\n",iX,fNanodes); @@ -105,94 +150,272 @@ Neighbours(Int_t iX, Int_t iZ, Int_t* Nlist, Int_t Xlist[8], Int_t Zlist[8]){ Zlist[2]=Zlist[3]=iZ; } //---------------------------------------------------------------------- -void AliITSsegmentationSDD::GetPadIxz(Float_t x,Float_t z, - Int_t &timebin,Int_t &anode){ -// Returns cell coordinates (time sample,anode) for given real local -// coordinates (x,z) +Float_t AliITSsegmentationSDD::GetAnodeFromLocal(Float_t xloc,Float_t zloc) const { + // returns anode coordinate (as float) starting from local coordinates + Float_t xAnode=zloc*fgkCm2Micron/fPitch; + if(xloc>0){ // left side (anodes 0-255, anode 0 at zloc<0) + xAnode+=(Float_t)fNanodes/4; + }else{ // right side (anodes 256-511, anode 0 at zloc>0) + xAnode=3*fNanodes/4-xAnode; + } + return xAnode; +} - // expects x, z in cm +//---------------------------------------------------------------------- +Float_t AliITSsegmentationSDD::GetLocalZFromAnode(Int_t nAnode) const{ + // returns local Z coordinate from anode number (integer) + Float_t zAnode=(Float_t)nAnode+0.5; + return GetLocalZFromAnode(zAnode); +} - const Float_t kconv=10000; // cm->um +//---------------------------------------------------------------------- +Float_t AliITSsegmentationSDD::GetLocalZFromAnode(Float_t zAnode) const{ + // returns local Z coordinate from anode number (float) + Float_t zloc=0.; + if(zAnode=fNanodes || iz<0 || ix>fNsamples){ + AliError("Bad cell number"); + return -1; + } + Int_t theChip=iz/fgkNanodesPerChip; + return theChip; +} +//---------------------------------------------------------------------- +Int_t AliITSsegmentationSDD::GetChipFromLocal(Float_t xloc, Float_t zloc) const { + // returns chip number (in range 0-7) starting from local coordinates + Float_t detsize=fDz*fgkMicron2Cm; + Float_t chipsize=detsize/(Float_t)fgkNchipsPerHybrid; + zloc+=detsize/2.; + if(zloc<-0.01 || zloc>detsize+0.01){ // 100 micron tolerance around edges + AliError("Z local value out of sensitive SDD area"); + return -1; + } + Int_t iChip=int(zloc/chipsize); + if(zloc<0.) iChip=0; + if(zloc>=detsize) iChip=fgkNchipsPerHybrid-1; + if(iChip>=fgkNchipsPerHybrid || iChip<0){ + AliError(Form("Bad chip number %d",iChip)); + return -1; + } + Int_t iSide=GetSideFromLocalX(xloc); + if(iSide==1) iChip=fgkNchipsPerHybrid-iChip+3; // i.e. 7-iChip + return iChip; +} +//---------------------------------------------------------------------- +Int_t AliITSsegmentationSDD::GetChipsInLocalWindow(Int_t* array, Float_t zmin, Float_t zmax, Float_t xmin, Float_t xmax) const { + Int_t nChipInW = 0; + Float_t zminDet=-fDz*fgkMicron2Cm/2.; + Float_t zmaxDet=fDz*fgkMicron2Cm/2.; + if(zminzmaxDet) zmax=zmaxDet; + Float_t xminDet=-fDx*fgkMicron2Cm; + Float_t xmaxDet=fDx*fgkMicron2Cm; + if(xminxmaxDet) xmax=xmaxDet; + Int_t n1=GetChipFromLocal(xmin,zmin); + array[nChipInW]=n1; + nChipInW++; + Int_t n2=GetChipFromLocal(xmin,zmax); + if(n2!=n1){ + Int_t imin=TMath::Min(n1,n2); + Int_t imax=TMath::Max(n1,n2); + for(Int_t ichip=imin; ichip<=imax; ichip++){ + if(ichip==n1) continue; + array[nChipInW]=ichip; + nChipInW++; + } + } + Int_t n3=GetChipFromLocal(xmax,zmin); + if(n3!=n1){ + array[nChipInW]=n3; + nChipInW++; + Int_t n4=GetChipFromLocal(xmax,zmax); + if(n4!=n3){ + Int_t imin=TMath::Min(n3,n4); + Int_t imax=TMath::Max(n3,n4); + for(Int_t ichip=imin; ichip<=imax; ichip++){ + if(ichip==n3) continue; + array[nChipInW]=ichip; + nChipInW++; + } + } + } + return nChipInW; +} +//---------------------------------------------------------------------- +void AliITSsegmentationSDD::GetPadIxz(Float_t x,Float_t z, + Int_t &timebin,Int_t &anode) const { +// Returns cell coordinates (time sample,anode) +// for given real local coordinates (x,z) - Float_t speed=fResponse->DriftSpeed(); - Int_t na = fNanodes/2; - Float_t driftpath=fDx-TMath::Abs(kconv*x); - timebin=(Int_t)(driftpath/speed/fTimeStep); - anode=(Int_t)(kconv*z/fPitch) + na/2; - if (x > 0) anode += na; + // expects x, z in cm - timebin+=1; - anode+=1; + Float_t driftpath=fDx-TMath::Abs(x*fgkCm2Micron); + timebin=(Int_t)(driftpath/fDriftSpeed/fTimeStep); + anode=(Int_t)GetAnodeFromLocal(x,z); + if(!fSetDriftSpeed){ + timebin=-999; + AliWarning("Drift speed not set: timebin is dummy"); + } } //---------------------------------------------------------------------- void AliITSsegmentationSDD::GetPadCxz(Int_t timebin,Int_t anode, - Float_t &x ,Float_t &z){ - // Transform from cell to real local coordinates - // returns x, z in cm - - const Float_t kconv=10000; // um->cm + Float_t &x ,Float_t &z) const{ + // Transform from cell to real local coordinates + // returns x, z in cm - Float_t speed=fResponse->DriftSpeed(); - Int_t na = fNanodes/2; - Float_t driftpath=(timebin+1)*fTimeStep*speed; - if (anode >= na) x=(fDx-driftpath)/kconv; - else x = -(fDx-driftpath)/kconv; - if (anode >= na) anode-=na; - z=((anode+1)*fPitch-fDz/2)/kconv; + // the +0.5 means that an # and time bin # should start from 0 !!! + // the +0.5 means that an # and time bin # should start from 0 !!! + Float_t driftpath=GetDriftTimeFromTb(timebin)*fDriftSpeed; + if (anode < fNanodes/2){ // left side, positive x + x=(fDx-driftpath)*fgkMicron2Cm; + }else{ // right side, negative x + x = -(fDx-driftpath)*fgkMicron2Cm; + } + z=GetLocalZFromAnode(anode); + if(!fSetDriftSpeed){ + x=-9999.; + AliWarning("Drift speed not set: x coord. is dummy"); + } } //---------------------------------------------------------------------- -void AliITSsegmentationSDD::GetPadTxz(Float_t &x,Float_t &z){ +void AliITSsegmentationSDD::GetPadTxz(Float_t &x,Float_t &z) const{ // Get anode and time bucket as floats - numbering from 0 // expects x, z in cm - const Float_t kconv=10000; // cm->um - - Float_t x0=x; - Float_t speed=fResponse->DriftSpeed(); - Int_t na = fNanodes/2; - Float_t driftpath=fDx-TMath::Abs(kconv*x); - x=driftpath/speed/fTimeStep; - z=kconv*z/fPitch + (float)na/2; - if (x0 < 0) x = -x; - -} -//---------------------------------------------------------------------- -void AliITSsegmentationSDD::GetLocal(Int_t module,Float_t *g ,Float_t *l){ - // returns local coordinates from global - if(!fGeom) { - return; - //fGeom = ((AliITS*)gAlice->GetModule("ITS"))->GetITSgeom(); - } - fGeom->GtoL(module,g,l); -} -//---------------------------------------------------------------------- -void AliITSsegmentationSDD::GetGlobal(Int_t module,Float_t *l ,Float_t *g){ - // return global coordinates from local - if(!fGeom) { - return; - //fGeom = ((AliITS*)gAlice->GetModule("ITS"))->GetITSgeom(); + Float_t xloc=x; + Float_t zloc=z; + Float_t driftpath=fDx-TMath::Abs(fgkCm2Micron*xloc); + x=driftpath/fDriftSpeed/fTimeStep; + if (xloc < 0) x = -x; + z=GetAnodeFromLocal(xloc,zloc); + if(!fSetDriftSpeed){ + x=-9999.; + AliWarning("Drift speed not set: x coord. is dummy"); } - - fGeom->LtoG(module,l,g); - } //---------------------------------------------------------------------- -void AliITSsegmentationSDD::Print(){ +void AliITSsegmentationSDD::Print(Option_t *opt) const { // Print SDD segmentation Parameters cout << "**************************************************" << endl; - cout << " Silicon Drift Detector Segmentation Parameters " << endl; + cout << " Silicon Drift Detector Segmentation Parameters " << opt << endl; cout << "**************************************************" << endl; cout << "Number of Time Samples: " << fNsamples << endl; cout << "Number of Anodes: " << fNanodes << endl; cout << "Time Step (ns): " << fTimeStep << endl; cout << "Anode Pitch (um): " << fPitch << endl; - cout << "Full Detector Width (x): " << fDx << endl; - cout << "Half Detector Length (z): " << fDz << endl; - cout << "Full Detector Thickness (y): " << fDy << endl; + cout << "Full Detector Width (x): " << fDx; + cout<<" (Default is "<-dx) { + AliWarning(Form("Input argument %f out of range (%f, %f)",x,dx,-dx)); + return kFALSE; // outside of defined volume. + } + if(z-dz) { + AliWarning(Form("Input argument %f out of range (%f, %f)",z,dz,-dz)); + return kFALSE; // outside of defined volume. + } + GetPadIxz(x,z,ix,iz); + if(!fSetDriftSpeed){ + ix=-999; + AliWarning("Drift speed not set: timebin is dummy"); + return kFALSE; + } + return kTRUE; // Found ix and iz, return. +} +//______________________________________________________________________ +void AliITSsegmentationSDD::DetToLocal(Int_t ix,Int_t iz,Float_t &x,Float_t &z) const +{ +// Transformation from Detector time bucket and anode coordiantes to Geant +// detector centerd local coordinates (cm). +// Input: +// Int_t ix detector x time coordinate. Has the range 0<=ix=Npx()) { + AliWarning(Form("Input argument %d out of range (0, %d)",ix,Npx())); + return; // outside of detector + } + if(iz<0 || iz>=Npz()) { + AliWarning(Form("Input argument %d out of range (0, %d)",iz,Npz())); + return; // outside of detctor + } + GetPadCxz(ix,iz,x,z); + if(!fSetDriftSpeed){ + x=-9999.; + AliWarning("Drift speed not set: x coord. is dummy"); + } + return; // Found x and z, return. +}