**************************************************************************/
/*
-$Id$
+$Id:$
*/
#include <Riostream.h>
#include "AliITSsimulationSPD.h"
#include "AliLog.h"
#include "AliRun.h"
-#include "AliCDBEntry.h"
-#include "AliCDBLocal.h"
+#include "AliMagF.h"
//#define DEBUG
// Modified by D. Elia, G.E. Bruno, H. Tydesjo
// Fast diffusion code by Bjorn S. Nilsen
// March-April 2006
+// October 2007: GetCalibrationObjects() removed
//
// Version: 0
// Written by Boris Batyunya
AliITSsimulation(),
fHis(0),
fSPDname(),
-fCoupling(){
+fCoupling(),
+fLorentz(kFALSE),
+fTanLorAng(0){
// Default constructor.
// Inputs:
// none.
AliITSsimulation(dettyp),
fHis(0),
fSPDname(),
-fCoupling(){
+fCoupling(),
+fLorentz(kFALSE),
+fTanLorAng(0){
// standard constructor
// Inputs:
// AliITSsegmentation *seg A pointer to the segmentation class
} else {
fCoupling=1;
} // end if
-
- // Get the calibration objects for each module(ladder)
- GetCalibrationObjects(0); //RunNr 0 hard coded for now
-
+ //SetLorentzDrift(kTRUE);
+ if (fLorentz) SetTanLorAngle();
+}
+//______________________________________________________________________
+Bool_t AliITSsimulationSPD::SetTanLorAngle(Double_t WeightHole) {
+ // This function set the Tangent of the Lorentz angle.
+ // A weighted average is used for electrons and holes
+ // Input: Double_t WeightHole: wheight for hole: it should be in the range [0,1]
+ // output: Bool_t : kTRUE in case of success
+ //
+ if(!fDetType) {
+ AliError("AliITSsimulationSPD::SetTanLorAngle: AliITSDetTypeSim* fDetType not set ");
+ return kFALSE;}
+ if(WeightHole<0) {
+ WeightHole=0.;
+ AliWarning("AliITSsimulationSPD::SetTanLorAngle: You have asked for negative Hole weight");
+ AliWarning("AliITSsimulationSPD::SetTanLorAngle: I'm going to use only electrons");
+ }
+ if(WeightHole>1) {
+ WeightHole=1.;
+ AliWarning("AliITSsimulationSPD::SetTanLorAngle: You have asked for weight > 1");
+ AliWarning("AliITSsimulationSPD::SetTanLorAngle: I'm going to use only holes");
+ }
+ Double_t WeightEle=1.-WeightHole;
+ AliITSCalibrationSPD* res = (AliITSCalibrationSPD*)GetCalibrationModel(fDetType->GetITSgeom()->GetStartSPD());
+ AliMagF *mf = gAlice->Field();
+ Float_t pos[3]={0.,0.,0.};
+ Float_t B[3]={0.,0.,0.};
+ mf->Field(pos,B);
+ fTanLorAng = TMath::Tan(WeightHole*res->LorentzAngleHole(B[2]) +
+ WeightEle*res->LorentzAngleElectron(B[2]));
+ fTanLorAng*=-1.; // this only for the old geometry
+ // comment the upper line for the new geometry
+ return kTRUE;
}
//______________________________________________________________________
AliITSsimulationSPD::~AliITSsimulationSPD(){
//______________________________________________________________________
AliITSsimulationSPD::AliITSsimulationSPD(const
AliITSsimulationSPD
- &s) : AliITSsimulation(s){
+ &s) : AliITSsimulation(s),
+fHis(s.fHis),
+fSPDname(s.fSPDname),
+fCoupling(s.fCoupling),
+fLorentz(s.fLorentz),
+fTanLorAng(s.fTanLorAng){
// Copy Constructor
// Inputs:
// AliITSsimulationSPD &s The original class for which
// none.
// Return:
- *this = s;
- return;
}
//______________________________________________________________________
AliITSsimulationSPD& AliITSsimulationSPD::operator=(const
this->fHis = s.fHis;
fCoupling = s.fCoupling;
fSPDname = s.fSPDname;
+ fLorentz = s.fLorentz;
+ fTanLorAng = s.fTanLorAng;
return *this;
}
//______________________________________________________________________
return *this;
}
-
-//______________________________________________________________________
-void AliITSsimulationSPD::GetCalibrationObjects(Int_t RunNr) {
- // Gets the calibration objects for each module (ladder)
- // Inputs:
- // RunNr: hard coded to RunNr=0 for now
- // Outputs:
- // none.
- // Return:
- // none.
-
- AliCDBManager* man = AliCDBManager::Instance();
- if(!man->IsDefaultStorageSet()) {
- man->SetDefaultStorage("local://$ALICE_ROOT");
- }
- AliCDBEntry *entrySPD = man->Get("ITS/Calib/CalibSPD", RunNr);
- if(!entrySPD){
- AliWarning("Cannot find SPD calibration entry!");
- return;
- }
- TObjArray *respSPD = (TObjArray *)entrySPD->GetObject();
- if ((! respSPD)) {
- AliWarning("Cannot get data from SPD database entry!");
- return;
- }
- for (Int_t mod=0; mod<240; mod++) {
- fCalObj[mod] = (AliITSCalibrationSPD*) respSPD->At(mod);
- }
-}
-
//______________________________________________________________________
void AliITSsimulationSPD::InitSimulationModule(Int_t module, Int_t event){
// This function creates maps to build the list of tracks for each
Int_t nhits = hits->GetEntriesFast();
Int_t h,ix,iz,i;
Int_t idtrack;
- Double_t x0=0.0,x1=0.0,y0=0.0,y1=0.0,z0=0.0,z1=0.0,de=0.0;
+ Double_t x0=0.0,x1=0.0,y0=0.0,y1=0.0,z0=0.0,z1=0.0,de=0.0,ld=0.0;
Double_t x,y,z,t,tp,st,dt=0.2,el,sig,sigx,sigz,fda;
AliITSsegmentationSPD* seg = (AliITSsegmentationSPD*)GetSegmentationModel(0);
AliITSCalibrationSPD* res = (AliITSCalibrationSPD*)GetCalibrationModel(fDetType->GetITSgeom()->GetStartSPD());
<<" de="<<de<<endl;
} // end if GetDebug
sig = res->SigmaDiffusion1D(TMath::Abs(thick + y));
- // SpreadCharge(x,z,ix,iz,el,sig,idtrack,h);
sigx=sig;
sigz=sig*fda;
- SpreadChargeAsym(x,z,ix,iz,el,sigx,sigz,idtrack,h);
- cout << "sigx, sigz, y "<< sigx << " " << sigz<< " " << TMath::Abs(thick + y) << endl;// ciccio
+ if (fLorentz) ld=(y+thick)*fTanLorAng;
+ SpreadChargeAsym(x,z,ix,iz,el,sigx,sigz,ld,idtrack,h);
} // end for t
} else { // st == 0.0 deposit it at this point
x = x0;
if(!(seg->LocalToDet(x,z,ix,iz))) continue; // outside
el = res->GeVToCharge((Double_t)de);
sig = res->SigmaDiffusion1D(TMath::Abs(thick + y));
- // SpreadCharge(x,z,ix,iz,el,sig,idtrack,h);
sigx=sig;
sigz=sig*fda;
- SpreadChargeAsym(x,z,ix,iz,el,sigx,sigz,idtrack,h);
+ if (fLorentz) ld=(y+thick)*fTanLorAng;
+ SpreadChargeAsym(x,z,ix,iz,el,sigx,sigz,ld,idtrack,h);
} // end if st>0.0
+
+ } // Loop over all hits h
+
// Coupling
switch (fCoupling) {
default:
} // end for i
break;
} // end switch
- } // Loop over all hits h
if(GetDebug(2))Info("HitToSDigit","Finished fCoupling=%d",fCoupling);
}
//______________________________________________________________________
Int_t nhits = hits->GetEntriesFast();
Int_t h,ix,iz,i;
Int_t idtrack;
- Double_t x0=0.0,x1=0.0,y0=0.0,y1=0.0,z0=0.0,z1=0.0,de=0.0;
+ Double_t x0=0.0,x1=0.0,y0=0.0,y1=0.0,z0=0.0,z1=0.0,de=0.0,ld=0.0;
Double_t x,y,z,t,st,el,sig,sigx,sigz,fda;
AliITSsegmentationSPD* seg = (AliITSsegmentationSPD*)GetSegmentationModel(0);
AliITSCalibrationSPD* res = (AliITSCalibrationSPD*)GetCalibrationModel(fDetType->GetITSgeom()->GetStartSPD());
sig = res->SigmaDiffusion1D(TMath::Abs(thick + y));
sigx=sig;
sigz=sig*fda;
- //SpreadCharge(x,z,ix,iz,el,sig,idtrack,h);
- SpreadChargeAsym(x,z,ix,iz,el,sigx,sigz,idtrack,h);
- // cout << "sigx sigz " << sigx << " " << sigz << endl; // dom
+ if (fLorentz) ld=(y+thick)*fTanLorAng;
+ SpreadChargeAsym(x,z,ix,iz,el,sigx,sigz,ld,idtrack,h);
+// cout << "sigx sigz " << sigx << " " << sigz << endl; // dom
} // end for i // End Integrate over t
else { // st == 0.0 deposit it at this point
x = x0;
if(!(seg->LocalToDet(x,z,ix,iz))) continue; // outside
el = res->GeVToCharge((Double_t)de);
sig = res->SigmaDiffusion1D(TMath::Abs(thick + y));
- //SpreadCharge(x,z,ix,iz,el,sig,idtrack,h);
sigx=sig;
sigz=sig*fda;
- SpreadChargeAsym(x,z,ix,iz,el,sigx,sigz,idtrack,h);
+ if (fLorentz) ld=(y+thick)*fTanLorAng;
+ SpreadChargeAsym(x,z,ix,iz,el,sigx,sigz,ld,idtrack,h);
} // end if st>0.0
+
+ } // Loop over all hits h
+
// Coupling
switch (fCoupling) {
default:
} // end for i
break;
} // end switch
- } // Loop over all hits h
if(GetDebug(2))Info("HitToSDigit","Finished fCoupling=%d",fCoupling);
}
//______________________________________________________________________
void AliITSsimulationSPD::SpreadCharge(Double_t x0,Double_t z0,
Int_t ix0,Int_t iz0,
- Double_t el,Double_t sig,Int_t t,
- Int_t hi){
+ Double_t el,Double_t sig,Double_t ld,
+ Int_t t,Int_t hi){
// Spreads the charge over neighboring cells. Assume charge is distributed
// as charge(x,z) = (el/2*pi*sig*sig)*exp(-arg)
// arg=((x-x0)*(x-x0)/2*sig*sig)+((z-z0*z-z0)/2*sig*sig)
+ // if fLorentz=kTRUE, then x0=x0+ld (Lorentz drift taken into account)
// Defined this way, the integral over all x and z is el.
// Inputs:
// Double_t x0 x position of point where charge is liberated
- // Double_t y0 y position of point where charge is liberated
// Double_t z0 z position of point where charge is liberated
// Int_t ix0 row of cell corresponding to point x0
// Int_t iz0 columb of cell corresponding to point z0
// Double_t el number of electrons liberated in this step
// Double_t sig Sigma difusion for this step (y0 dependent)
+ // Double_t ld lorentz drift in x for this step (y0 dependent)
// Int_t t track number
// Int_t ti hit track index number
// Int_t hi hit "hit" index number
x1 -= 0.5*kmictocm*seg->Dpx(ix); // Lower
z2 = z1 + 0.5*kmictocm*seg->Dpz(iz); // Upper
z1 -= 0.5*kmictocm*seg->Dpz(iz); // Lower
- x1 -= x0; // Distance from where track traveled
- x2 -= x0; // Distance from where track traveled
+ x1 -= x0+ld; // Distance from where track traveled (taking into account the Lorentz drift)
+ x2 -= x0+ld; // Distance from where track traveled (taking into account the Lorentz drift)
z1 -= z0; // Distance from where track traveled
z2 -= z0; // Distance from where track traveled
s = 0.25; // Correction based on definision of Erfc
void AliITSsimulationSPD::SpreadChargeAsym(Double_t x0,Double_t z0,
Int_t ix0,Int_t iz0,
Double_t el,Double_t sigx,Double_t sigz,
- Int_t t,Int_t hi){
+ Double_t ld,Int_t t,Int_t hi){
// Spreads the charge over neighboring cells. Assume charge is distributed
// as charge(x,z) = (el/2*pi*sigx*sigz)*exp(-arg)
// arg=((x-x0)*(x-x0)/2*sigx*sigx)+((z-z0*z-z0)/2*sigz*sigz)
+ // if fLorentz=kTRUE, then x0=x0+ld (Lorentz drift taken into account)
// Defined this way, the integral over all x and z is el.
// Inputs:
// Double_t x0 x position of point where charge is liberated
- // Double_t y0 y position of point where charge is liberated
// Double_t z0 z position of point where charge is liberated
// Int_t ix0 row of cell corresponding to point x0
// Int_t iz0 columb of cell corresponding to point z0
// Double_t el number of electrons liberated in this step
// Double_t sigx Sigma difusion along x for this step (y0 dependent)
// Double_t sigz Sigma difusion along z for this step (y0 dependent)
+ // Double_t ld lorentz drift in x for this stip (y0 dependent)
// Int_t t track number
// Int_t ti hit track index number
// Int_t hi hit "hit" index number
AliITSsegmentationSPD* seg = (AliITSsegmentationSPD*)GetSegmentationModel(0);
- if(GetDebug(4)) Info("SpreadCharge","(x0=%e,z0=%e,ix0=%d,iz0=%d,el=%e,"
+ if(GetDebug(4)) Info("SpreadChargeAsym","(x0=%e,z0=%e,ix0=%d,iz0=%d,el=%e,"
"sig=%e,t=%d,i=%d)",x0,z0,ix0,iz0,el,sigx,sigz,t,hi);
if(sigx<=0.0 || sigz<=0.0) { // if sig<=0 No diffusion to simulate.
GetMap()->AddSignal(iz0,ix0,t,hi,GetModuleNumber(),el);
x1 -= 0.5*kmictocm*seg->Dpx(ix); // Lower
z2 = z1 + 0.5*kmictocm*seg->Dpz(iz); // Upper
z1 -= 0.5*kmictocm*seg->Dpz(iz); // Lower
- x1 -= x0; // Distance from where track traveled
- x2 -= x0; // Distance from where track traveled
+ x1 -= x0+ld; // Distance from where track traveled (taking into account the Lorentz drift)
+ x2 -= x0+ld; // Distance from where track traveled (taking into account the Lorentz drift)
z1 -= z0; // Distance from where track traveled
z2 -= z0; // Distance from where track traveled
s = 0.25; // Correction based on definision of Erfc
// none.
Int_t moduleNr = mod->GetIndex();
- Int_t nrDead = fCalObj[moduleNr]->GetNrDead();
+ AliITSCalibrationSPD* calObj = (AliITSCalibrationSPD*) GetCalibrationModel(moduleNr);
+
+ Int_t nrDead = calObj->GetNrBad();
+// cout << "Module --> " << moduleNr << endl; // dom
+// cout << "nr of dead " << nrDead << endl; // dom
for (Int_t i=0; i<nrDead; i++) {
- GetMap()->DeleteHit(fCalObj[moduleNr]->GetDeadColAt(i),fCalObj[moduleNr]->GetDeadRowAt(i));
+ GetMap()->DeleteHit(calObj->GetBadColAt(i),calObj->GetBadRowAt(i));
+// cout << "dead index " << i << endl; // dom
+// cout << "col row --> " << calObj->GetDeadColAt(i) << " " << calObj->GetDeadRowAt(i) << endl; // dom
}
}
//______________________________________________________________________
Int_t j,ix,iz;
Double_t electronics;
Double_t sig;
- const Int_t knmaxtrk=AliITSdigitSPD::GetNTracks();
+ const Int_t knmaxtrk=AliITSdigit::GetNTracks();
static AliITSdigitSPD dig;
AliITSCalibrationSPD* res = (AliITSCalibrationSPD*)GetCalibrationModel(fDetType->GetITSgeom()->GetStartSPD());
if(GetDebug(1)) Info("FrompListToDigits","()");
// Debugging ...
// cout << "Threshold --> " << GetThreshold() << endl; // dom
-// cout << "Couplings --> " << couplC << " " << couplR << endl; //dom
-
+// cout << "Couplings --> " << couplC << " " << couplR << endl; // dom
if(GetDebug(3)) Info("SetCouplingOld","(col=%d,row=%d,ntrack=%d,idhit=%d) "
"Calling SetCoupling couplC=%e couplR=%e",
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff