X-Git-Url: http://git.uio.no/git/?a=blobdiff_plain;f=ITS%2FAliITSsimulationSPD.cxx;h=ac65a13e6345d7eded82390dbd4553d5ab3e9b6e;hb=a189acce21c91c9ee9e62e5926b310d3d278b46f;hp=f478d7376159c3346b997bb8dbe283f7300d597e;hpb=21b825a49085800d20554f1db24889054d89c89a;p=u%2Fmrichter%2FAliRoot.git diff --git a/ITS/AliITSsimulationSPD.cxx b/ITS/AliITSsimulationSPD.cxx index f478d737615..ac65a13e634 100644 --- a/ITS/AliITSsimulationSPD.cxx +++ b/ITS/AliITSsimulationSPD.cxx @@ -1,721 +1,1030 @@ -#include -#include +/************************************************************************** +* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. * +* * +* Author: The ALICE Off-line Project. * +* Contributors are mentioned in the code where appropriate. * +* * +* Permission to use, copy, modify and distribute this software and its * +* documentation strictly for non-commercial purposes is hereby granted * +* without fee, provided that the above copyright notice appears in all * +* copies and that both the copyright notice and this permission notice * +* appear in the supporting documentation. The authors make no claims * +* about the suitability of this software for any purpose. It is * +* provided "as is" without express or implied warranty. * +**************************************************************************/ + +/* +$Id$ +*/ + +#include +#include #include -#include #include -#include - - -#include "AliRun.h" #include "AliITS.h" +#include "AliITSdigitSPD.h" #include "AliITShit.h" -#include "AliITSdigit.h" #include "AliITSmodule.h" -#include "AliITSMapA2.h" +#include "AliITSpList.h" +#include "AliITSCalibrationSPD.h" +#include "AliITSsegmentationSPD.h" #include "AliITSsimulationSPD.h" -#include "AliITSsegmentation.h" -#include "AliITSresponse.h" +#include "AliLog.h" +#include "AliRun.h" +#include "AliMagF.h" +#include "AliMathBase.h" +//#define DEBUG +using std::endl; +using std::cout; ClassImp(AliITSsimulationSPD) //////////////////////////////////////////////////////////////////////// -// Version: 0 -// Written by Rocco Caliandro -// from a model developed with T. Virgili and R.A. Fini -// June 15 2000 +// Version: 1 +// Modified by D. Elia, G.E. Bruno, H. Tydesjo +// Fast diffusion code by Bjorn S. Nilsen +// March-April 2006 +// October 2007: GetCalibrationObjects() removed // -// AliITSsimulationSPD is the simulation of SPDs +// Version: 0 +// Written by Boris Batyunya +// December 20 1999 // -//________________________________________________________________________ - -AliITSsimulationSPD::AliITSsimulationSPD(){ - // constructor - fResponse = 0; - fSegmentation = 0; - fHis = 0; - fThresh = 0.; - fSigma = 0.; - fCouplCol = 0.; - fCouplRow = 0.; -} -//_____________________________________________________________________________ +// +// AliITSsimulationSPD is to do the simulation of SPDs. +// +//////////////////////////////////////////////////////////////////////// -AliITSsimulationSPD::AliITSsimulationSPD(AliITSsegmentation *seg, AliITSresponse *resp) { - // constructor - fResponse = resp; - fSegmentation = seg; +//______________________________________________________________________ +AliITSsimulationSPD::AliITSsimulationSPD(): +AliITSsimulation(), +fHis(0), +fSPDname(), +fCoupling(), +fLorentz(kFALSE), +fTanLorAng(0), +fStrobe(kTRUE), +fStrobeLenght(4), +fStrobePhase(-12.5e-9){ + // Default constructor. + // Inputs: + // none. + // Outputs: + // none. + // Return: + // A default constructed AliITSsimulationSPD class. + + AliDebug(1,Form("Calling default constructor")); +// Init(); +} +//______________________________________________________________________ +AliITSsimulationSPD::AliITSsimulationSPD(AliITSDetTypeSim *dettyp): +AliITSsimulation(dettyp), +fHis(0), +fSPDname(), +fCoupling(), +fLorentz(kFALSE), +fTanLorAng(0), +fStrobe(kTRUE), +fStrobeLenght(4), +fStrobePhase(-12.5e-9){ + // standard constructor + // Inputs: + // AliITSsegmentation *seg A pointer to the segmentation class + // to be used for this simulation + // AliITSCalibration *resp A pointer to the responce class to + // be used for this simulation + // Outputs: + // none. + // Return: + // A default constructed AliITSsimulationSPD class. + + AliDebug(1,Form("Calling standard constructor ")); + Init(); +} +//______________________________________________________________________ +void AliITSsimulationSPD::Init(){ + // Initilization + // Inputs: + // none. + // Outputs: + // none. + // Return: + // none. + const Double_t kmictocm = 1.0e-4; // convert microns to cm. + + SetModuleNumber(0); + SetEventNumber(0); + SetMap(new AliITSpList(GetNPixelsZ(),GetNPixelsX())); + AliITSSimuParam* simpar = fDetType->GetSimuParam(); + AliITSsegmentationSPD* seg = (AliITSsegmentationSPD*)GetSegmentationModel(0); + Double_t bias = simpar->GetSPDBiasVoltage(); +// cout << "Bias Voltage --> " << bias << endl; // dom + simpar->SetDistanceOverVoltage(kmictocm*seg->Dy(),bias); +// set kind of coupling ("old" or "new") + char opt[20]; + simpar->GetSPDCouplingOption(opt); + char *old = strstr(opt,"old"); + if (old) { + fCoupling=2; + } else { + fCoupling=1; + } // end if + SetLorentzDrift(simpar->GetSPDLorentzDrift()); + if (fLorentz) SetTanLorAngle(simpar->GetSPDLorentzHoleWeight()); + //SetStrobeGeneration(kFALSE); + if (fStrobe) GenerateStrobePhase(); +} +//______________________________________________________________________ +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; + AliITSSimuParam* simpar = fDetType->GetSimuParam(); + AliMagF* fld = (AliMagF*)TGeoGlobalMagField::Instance()->GetField(); + if (!fld) AliFatal("The field is not initialized"); + Double_t bz = fld->SolenoidField(); + fTanLorAng = TMath::Tan(WeightHole*simpar->LorentzAngleHole(bz) + + WeightEle*simpar->LorentzAngleElectron(bz)); + return kTRUE; +} +//______________________________________________________________________ +AliITSsimulationSPD::~AliITSsimulationSPD(){ + // destructor + // Inputs: + // none. + // Outputs: + // none. + // Return: + // none. + + if (fHis) { + fHis->Delete(); + delete fHis; + } // end if fHis +} +//______________________________________________________________________ +AliITSsimulationSPD::AliITSsimulationSPD(const + AliITSsimulationSPD + &s) : AliITSsimulation(s), +fHis(s.fHis), +fSPDname(s.fSPDname), +fCoupling(s.fCoupling), +fLorentz(s.fLorentz), +fTanLorAng(s.fTanLorAng), +fStrobe(s.fStrobe), +fStrobeLenght(s.fStrobeLenght), +fStrobePhase(s.fStrobePhase){ + // Copy Constructor + // Inputs: + // AliITSsimulationSPD &s The original class for which + // this class is a copy of + // Outputs: + // none. + // Return: - fResponse->Thresholds(fThresh,fSigma); - fResponse->GetNoiseParam(fCouplCol,fCouplRow); - - fMapA2 = new AliITSMapA2(fSegmentation); +} +//______________________________________________________________________ +AliITSsimulationSPD& AliITSsimulationSPD::operator=(const + AliITSsimulationSPD &s){ + // Assignment operator + // Inputs: + // AliITSsimulationSPD &s The original class for which + // this class is a copy of + // Outputs: + // none. + // Return: + + if(&s == this) return *this; + this->fHis = s.fHis; + fCoupling = s.fCoupling; + fSPDname = s.fSPDname; + fLorentz = s.fLorentz; + fTanLorAng = s.fTanLorAng; + fStrobe = s.fStrobe; + fStrobeLenght = s.fStrobeLenght; + fStrobePhase = s.fStrobePhase; + return *this; +} +/* +//______________________________________________________________________ +AliITSsimulation& AliITSsimulationSPD::operator=(const + AliITSsimulation &s){ + // Assignment operator + // Inputs: + // AliITSsimulationSPD &s The original class for which + // this class is a copy of + // Outputs: + // none. + // Return: + + if(&s == this) return *this; + Error("AliITSsimulationSPD","Not allowed to make a = with " + "AliITSsimulationSPD","Using default creater instead"); + + return *this; +} +*/ +//______________________________________________________________________ +void AliITSsimulationSPD::InitSimulationModule(Int_t module, Int_t event){ + // This function creates maps to build the list of tracks for each + // summable digit. Inputs defined by base class. + // Inputs: + // Int_t module // Module number to be simulated + // Int_t event // Event number to be simulated + // Outputs: + // none + // Returns: + // none + + AliDebug(1,Form("(module=%d,event=%d)",module,event)); + const Double_t kmictocm = 1.0e-4; // convert microns to cm. + AliITSSimuParam* simpar = fDetType->GetSimuParam(); + AliITSsegmentationSPD* seg = (AliITSsegmentationSPD*)GetSegmentationModel(0); + SetModuleNumber(module); + SetEventNumber(event); + simpar->SetDistanceOverVoltage(kmictocm*seg->Dy(),simpar->GetSPDBiasVoltage(module)); + ClearMap(); +} +//_____________________________________________________________________ +void AliITSsimulationSPD::SDigitiseModule(AliITSmodule *mod,Int_t, + Int_t event){ + // This function begins the work of creating S-Digits. Inputs defined + // by base class. + // Inputs: + // AliITSmodule *mod // module + // Int_t // not used + // Int_t event // Event number + // Outputs: + // none + // Return: + // test // test returns kTRUE if the module contained hits + // // test returns kFALSE if it did not contain hits + + AliDebug(1,Form("(mod=%p, ,event=%d)",mod,event)); + if(!(mod->GetNhits())){ + AliDebug(1,Form("In event %d module %d there are %d hits returning.", + event, mod->GetIndex(),mod->GetNhits())); + return;// if module has no hits don't create Sdigits + } // end if + SetModuleNumber(mod->GetIndex()); + if (fStrobe) if(event != GetEventNumber()) GenerateStrobePhase(); + SetEventNumber(event); + InitSimulationModule( GetModuleNumber() , event ); + // HitToSDigit(mod); + HitToSDigitFast(mod); + if (fDetType->GetSimuParam()->GetSPDAddNoisyFlag()) AddNoisyPixels(); + if (fDetType->GetSimuParam()->GetSPDRemoveDeadFlag()) RemoveDeadPixels(); + +// cout << "After Remove in SDigitiseModule !!!!!" << endl; // dom +// cout << "Module " << mod->GetIndex() << " Event " << event << endl; // dom + WriteSDigits(); + ClearMap(); +} +//______________________________________________________________________ +void AliITSsimulationSPD::WriteSDigits(){ + // This function adds each S-Digit to pList + // Inputs: + // none. + // Outputs: + // none. + // Return: + // none + Int_t ix, nix, iz, niz; + static AliITS *aliITS = (AliITS*)gAlice->GetModule("ITS"); + + AliDebug(1,Form("Writing SDigits for module %d",GetModuleNumber())); +// cout << "WriteSDigits for module " << GetModuleNumber() << endl; // dom + GetMap()->GetMaxMapIndex(niz, nix); + for(iz=0; izGetSignalOnly(iz,ix)>0.0){ +// cout << " Signal gt 0 iz ix " << iz << ix << " Module " << GetModuleNumber() << endl; // dom + aliITS->AddSumDigit(*(GetMap()->GetpListItem(iz,ix))); + if(AliDebugLevel()>0) { + AliDebug(1,Form("%d, %d",iz,ix)); + cout << *(GetMap()->GetpListItem(iz,ix)) << endl; + } // end if GetDebug + } // end if GetMap()->GetSignalOnly(iz,ix)>0.0 + } // end for iz,ix + return; +} +//______________________________________________________________________ +void AliITSsimulationSPD::FinishSDigitiseModule(){ + // This function calls SDigitsToDigits which creates Digits from SDigits + // Inputs: + // none + // Outputs: + // none + // Return + // none + + AliDebug(1,"()"); +// cout << "FinishSDigitiseModule for module " << GetModuleNumber() << endl; // dom + FrompListToDigits(); // Charge To Signal both adds noise and + ClearMap(); + return; +} +//______________________________________________________________________ +void AliITSsimulationSPD::DigitiseModule(AliITSmodule *mod,Int_t, + Int_t event){ + // This function creates Digits straight from the hits and then adds + // electronic noise to the digits before adding them to pList + // Each of the input variables is passed along to HitToSDigit + // Inputs: + // AliITSmodule *mod module + // Int_t Dummy. + // Int_t Dummy + // Outputs: + // none. + // Return: + // none. + + if (fStrobe) if(event != GetEventNumber()) GenerateStrobePhase(); + AliDebug(1,Form("(mod=%p,,0)",mod)); + // HitToSDigit(mod); + InitSimulationModule( mod->GetIndex(), event ); + HitToSDigitFast(mod); - // - fNPixelsZ=fSegmentation->Npz(); - fNPixelsX=fSegmentation->Npx(); - fHis=0; + if (fDetType->GetSimuParam()->GetSPDAddNoisyFlag()) AddNoisyPixels(); + if (fDetType->GetSimuParam()->GetSPDRemoveDeadFlag()) RemoveDeadPixels(); +// cout << "After Remove in DigitiseModule in module " << mod->GetIndex() << endl; // dom + FrompListToDigits(); + ClearMap(); } - -//_____________________________________________________________________________ - -AliITSsimulationSPD::~AliITSsimulationSPD() { - // destructor - - delete fMapA2; - - if (fHis) { - fHis->Delete(); - delete fHis; - } +//______________________________________________________________________ +void AliITSsimulationSPD::HitToSDigit(AliITSmodule *mod){ + // Does the charge distributions using Gaussian diffusion charge charing. + // Inputs: + // AliITSmodule *mod Pointer to this module + // Output: + // none. + // Return: + // none. + const Double_t kmictocm = 1.0e-4; // convert microns to cm. + const Double_t kBunchLenght = 25e-9; // LHC clock + TObjArray *hits = mod->GetHits(); + 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,ld=0.0; + Double_t x,y,z,t,tp,st,dt=0.2,el,sig,sigx,sigz,fda; + AliITSsegmentationSPD* seg = (AliITSsegmentationSPD*)GetSegmentationModel(0); + AliITSSimuParam *simpar = fDetType->GetSimuParam(); + Double_t thick = 0.5*kmictocm*seg->Dy(); // Half Thickness + simpar->GetSPDSigmaDiffusionAsymmetry(fda); // + + AliDebug(1,Form("(mod=%p) fCoupling=%d",mod,fCoupling)); + if(nhits<=0) return; + for(h=0;h0) { + AliDebug(1,Form("Hits, %d", h)); + cout << *(mod->GetHit(h)) << endl; + } // end if GetDebug + // Check if the hit is inside readout window + if (fStrobe) + if ((mod->GetHit(h)->GetTOF() < fStrobePhase) || + (mod->GetHit(h)->GetTOF() > (fStrobePhase+(Double_t)fStrobeLenght*kBunchLenght))) continue; + if(!mod->LineSegmentL(h,x0,x1,y0,y1,z0,z1,de,idtrack)) continue; + st = TMath::Sqrt(x1*x1+y1*y1+z1*z1); + if(st>0.0){ + st = (Double_t)((Int_t)(st/kmictocm)); // number of microns + if(st<=1.0) st = 1.0; + dt = 1.0/st; + for(t=0.0;t<1.0;t+=dt){ // Integrate over t + tp = t+0.5*dt; + x = x0+x1*tp; + y = y0+y1*tp; + z = z0+z1*tp; + if(!(seg->LocalToDet(x,z,ix,iz))) continue; // outside + //el = res->GeVToCharge((Double_t)(dt*de)); + el = dt * de / simpar->GetGeVToCharge(); + if(GetDebug(1)){ + if(el<=0.0) cout<<"el="<fMapA2 = source.fMapA2; - this->fThresh = source.fThresh; - this->fSigma = source.fSigma; - this->fCouplCol = source.fCouplCol; - this->fCouplRow = source.fCouplRow; - this->fNPixelsX = source.fNPixelsX; - this->fNPixelsZ = source.fNPixelsZ; - this->fHis = source.fHis; - return; +//______________________________________________________________________ +void AliITSsimulationSPD::HitToSDigitFast(AliITSmodule *mod){ + // Does the charge distributions using Gaussian diffusion charge charing. // Inputs: + // AliITSmodule *mod Pointer to this module + // Output: + // none. + // Return: + // none. + const Double_t kmictocm = 1.0e-4; // convert microns to cm. + const Int_t kn10=10; + const Double_t kti[kn10]={7.443716945e-3,2.166976971e-1,3.397047841e-1, + 4.325316833e-1,4.869532643e-1,5.130467358e-1, + 5.674683167e-1,6.602952159e-1,7.833023029e-1, + 9.255628306e-1}; + const Double_t kwi[kn10]={1.477621124e-1,1.346333597e-1,1.095431813e-1, + 7.472567455e-2,3.333567215e-2,3.333567215e-2, + 7.472567455e-2,1.095431813e-1,1.346333597e-1, + 1.477621124e-1}; + const Double_t kBunchLenght = 25e-9; // LHC clock + TObjArray *hits = mod->GetHits(); + 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,ld=0.0; + Double_t x,y,z,t,st,el,sig,sigx,sigz,fda; + AliITSsegmentationSPD* seg = (AliITSsegmentationSPD*)GetSegmentationModel(0); + AliITSSimuParam* simpar = fDetType->GetSimuParam(); + Double_t thick = 0.5*kmictocm*seg->Dy(); // Half thickness + simpar->GetSPDSigmaDiffusionAsymmetry(fda); +// cout << "Half Thickness " << thick << endl; // dom +// cout << "Diffusion asymm " << fda << endl; // dom + + AliDebug(1,Form("(mod=%p) fCoupling=%d",mod,fCoupling)); + if(nhits<=0) return; + for(h=0;h0) { + AliDebug(1,Form("Hits, %d", h)); + cout << *(mod->GetHit(h)) << endl; + } // end if GetDebug + // Check if the hit is inside readout window + if (fStrobe) + if ((mod->GetHit(h)->GetTOF() < fStrobePhase) || + (mod->GetHit(h)->GetTOF() > (fStrobePhase+(Double_t)fStrobeLenght*kBunchLenght))) continue; + if(!mod->LineSegmentL(h,x0,x1,y0,y1,z0,z1,de,idtrack)) continue; + st = TMath::Sqrt(x1*x1+y1*y1+z1*z1); + if(st>0.0) for(i=0;iLocalToDet(x,z,ix,iz))) continue; // outside + el = kwi[i]*de/simpar->GetGeVToCharge(); + if(GetDebug(1)){ + if(el<=0.0) cout<<"el="<LocalToDet(x,z,ix,iz))) continue; // outside + el = de / simpar->GetGeVToCharge(); + sig = simpar->SigmaDiffusion1D(TMath::Abs(thick + y)); + sigx=sig; + sigz=sig*fda; + 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: + break; + case 1: // case 3: + for(i=0;iGetEntries();i++) + if(GetMap()->GetpListItem(i)==0) continue; + else{ + GetMap()->GetMapIndex(GetMap()->GetpListItem(i)->GetIndex(),iz,ix); + SetCoupling(iz,ix); + } // end for i + break; + case 2: // case 4: + for(i=0;iGetEntries();i++) + if(GetMap()->GetpListItem(i)==0) continue; + else{ + GetMap()->GetMapIndex(GetMap()->GetpListItem(i)->GetIndex(),iz,ix); + SetCouplingOld(iz,ix); + } // end for i + break; + } // end switch + if(GetDebug(2))Info("HitToSDigit","Finished fCoupling=%d",fCoupling); } - -//_________________________________________________________________________ -AliITSsimulationSPD& - AliITSsimulationSPD::operator=(const AliITSsimulationSPD &source) { - // Assignment operator - if(&source == this) return *this; - this->fMapA2 = source.fMapA2; - this->fThresh = source.fThresh; - this->fSigma = source.fSigma; - this->fCouplCol = source.fCouplCol; - this->fCouplRow = source.fCouplRow; - this->fNPixelsX = source.fNPixelsX; - this->fNPixelsZ = source.fNPixelsZ; - this->fHis = source.fHis; - return *this; +//______________________________________________________________________ +void AliITSsimulationSPD::SpreadCharge(Double_t x0,Double_t z0, + Int_t ix0,Int_t iz0, + 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 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 + // Outputs: + // none. + // Return: + // none. + const Int_t knx = 3,knz = 2; + const Double_t kRoot2 = 1.414213562; // Sqrt(2). + const Double_t kmictocm = 1.0e-4; // convert microns to cm. + Int_t ix,iz,ixs,ixe,izs,ize; + Float_t x,z; + Double_t x1,x2,z1,z2,s,sp; + AliITSsegmentationSPD* seg = (AliITSsegmentationSPD*)GetSegmentationModel(0); + + + if(GetDebug(4)) Info("SpreadCharge","(x0=%e,z0=%e,ix0=%d,iz0=%d,el=%e," + "sig=%e,t=%d,i=%d)",x0,z0,ix0,iz0,el,sig,t,hi); + if(sig<=0.0) { // if sig<=0 No diffusion to simulate. + GetMap()->AddSignal(iz0,ix0,t,hi,GetModuleNumber(),el); + if(GetDebug(2)){ + cout << "sig<=0.0=" << sig << endl; + } // end if GetDebug + return; + } // end if + sp = 1.0/(sig*kRoot2); + if(GetDebug(2)){ + cout << "sig=" << sig << " sp=" << sp << endl; + } // end if GetDebug + ixs = TMath::Max(-knx+ix0,0); + ixe = TMath::Min(knx+ix0,seg->Npx()-1); + izs = TMath::Max(-knz+iz0,0); + ize = TMath::Min(knz+iz0,seg->Npz()-1); + for(ix=ixs;ix<=ixe;ix++) for(iz=izs;iz<=ize;iz++){ + seg->DetToLocal(ix,iz,x,z); // pixel center + x1 = x; + z1 = z; + x2 = x1 + 0.5*kmictocm*seg->Dpx(ix); // Upper + 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+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 + s *= AliMathBase::ErfcFast(sp*x1) - AliMathBase::ErfcFast(sp*x2); + if(GetDebug(3)){ + cout <<"el="<AddSignal(iz0,ix0,t,hi,GetModuleNumber(),el); + if(GetDebug(2)){ + cout << "sigx<=0.0=" << sigx << endl; + cout << "sigz<=0.0=" << sigz << endl; + } // end if GetDebug + return; + } // end if + spx = 1.0/(sigx*kRoot2); spz = 1.0/(sigz*kRoot2); + if(GetDebug(2)){ + cout << "sigx=" << sigx << " spx=" << spx << endl; + cout << "sigz=" << sigz << " spz=" << spz << endl; + } // end if GetDebug + ixs = TMath::Max(-knx+ix0,0); + ixe = TMath::Min(knx+ix0,seg->Npx()-1); + izs = TMath::Max(-knz+iz0,0); + ize = TMath::Min(knz+iz0,seg->Npz()-1); + for(ix=ixs;ix<=ixe;ix++) for(iz=izs;iz<=ize;iz++){ + seg->DetToLocal(ix,iz,x,z); // pixel center + x1 = x; + z1 = z; + x2 = x1 + 0.5*kmictocm*seg->Dpx(ix); // Upper + 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+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 + s *= AliMathBase::ErfcFast(spx*x1) - AliMathBase::ErfcFast(spx*x2); + if(GetDebug(3)){ + cout <<"el="<ClearMap(); - delete [] pList; - } -//_____________________________________________________________________________ - -void AliITSsimulationSPD::UpdateMap( Int_t row, Int_t col, Double_t ene) { -// -// updates the Map of signal, adding the energy (ene) released by the current track -// - Double_t signal; - signal = fMapA2->GetSignal(row,col); - signal += ene; - fMapA2->SetHit(row,col,signal); - - } -//_____________________________________________________________________________ -void AliITSsimulationSPD::HitToDigit(AliITSmodule *mod, Int_t hitpos, Int_t module, - Int_t *frowpixel, Int_t *fcolpixel, - Double_t *fenepixel, Float_t **pList) { -// -// Steering function to determine the digits associated to a given hit (hitpos) -// The digits are created by charge sharing (ChargeSharing) and by -// capacitive coupling (SetCoupling). At all the created digits is associated -// the track number of the hit (ntrack) -// - - - static Float_t x1l,y1l,z1l; - Float_t x2l,y2l,z2l,etot; - Int_t layer,r1,r2,c1,c2,row,col,npixel = 0; - Int_t ntrack,idhit; - Double_t ene; - const Float_t kconv = 10000.; // cm -> microns - const Float_t kconv1= 0.277e9; // GeV -> electrons equivalent - - TObjArray *fHits = mod->GetHits(); - AliITShit *hit = (AliITShit*) fHits->At(hitpos); - layer = hit->GetLayer(); - etot=kconv1*hit->GetIonization(); - ntrack=hit->GetTrack(); - idhit=mod->GetHitHitIndex(hitpos); - - - /* - printf("\n layer,etot,ntrack,status %d %f %d %d\n",layer,etot,ntrack,hit->GetTrackStatus()); //debug - Int_t idtrack; //debug - mod->GetHitTrackAndHitIndex(hitpos,idtrack,idhit); - printf("idtrack,idhit %d %d\n",idtrack,idhit); //debug - printf("(Dx, Dz)=(%f, %f)\n",fSegmentation->Dx(),fSegmentation->Dz()); //debug - */ - - - - if (hit->GetTrackStatus()==66) { - hit->GetPositionL(x1l,y1l,z1l); - // positions shifted and converted in microns - x1l = x1l*kconv + fSegmentation->Dx()/2.; - z1l = z1l*kconv + fSegmentation->Dz()/2.; - //printf("(x1l, z2l)=(%f, %f)\n",x1l,z1l); //debug - } - else { - hit->GetPositionL(x2l,y2l,z2l); - // positions shifted and converted in microns - x2l = x2l*kconv + fSegmentation->Dx()/2.; - z2l = z2l*kconv + fSegmentation->Dz()/2.; - //printf("(x2l, z2l)=(%f, %f)\n",x2l,z2l); //debug - - - - // to account for the effective sensitive area - // introduced in geometry - if (z1l<0 || z1l>fSegmentation->Dz()) return; - if (z2l<0 || z2l>fSegmentation->Dz()) return; - if (x1l<0 || x1l>fSegmentation->Dx()) return; - if (x2l<0 || x2l>fSegmentation->Dx()) return; - - //Get the col and row number starting from 1 - // the x direction is not inverted for the second layer!!! - fSegmentation->GetPadIxz(x1l, z1l, c1, r1); - fSegmentation->GetPadIxz(x2l, z2l, c2, r2); - - //printf("(c1, r1)=(%d, %d) (c2, r2)=(%d, %d)\n",c1,r1,c2,r2); //debug - - // to account for unexpected equal entrance and - // exit coordinates - if (x1l==x2l) x2l=x2l+x2l*0.000001; - if (z1l==z2l) z2l=z2l+z2l*0.000001; - - - if ((r1==r2) && (c1==c2)) - { - // no charge sharing - npixel = 1; - frowpixel[npixel-1] = r1; - fcolpixel[npixel-1] = c1; - fenepixel[npixel-1] = etot; - } - else { - // charge sharing - ChargeSharing(x1l,z1l,x2l,z2l,c1,r1,c2,r2,etot, - npixel,frowpixel,fcolpixel,fenepixel); - - } - - - for (Int_t npix=0;npixGetSPDNoisyModel(mod); + + Int_t nrNoisy = calObj->GetNrBad(); + for (Int_t i=0; iAddNoise(calObj->GetBadColAt(i), calObj->GetBadRowAt(i), mod, 10*GetThreshold()); + } } - -//_________________________________________________________________________ - -void AliITSsimulationSPD::ChargeSharing(Float_t x1l,Float_t z1l,Float_t x2l, - Float_t z2l,Int_t c1,Int_t r1,Int_t c2, - Int_t r2,Float_t etot, - Int_t &npixel,Int_t *frowpixel, - Int_t *fcolpixel,Double_t *fenepixel){ - // - // Take into account the geometrical charge sharing when the track - // crosses more than one pixel. - // - //Begin_Html - /* - - -
- - . - -
-  */
-  //End_Html
-
-
-   Float_t xa,za,xb,zb,dx,dz,dtot,dm,refr,refm,refc;
-   Float_t refn=0.;
-   Float_t arefm, arefr, arefn, arefc, azb, az2l, axb, ax2l;
-   Int_t   dirx,dirz,rb,cb;
-
-
-   Int_t flag,flagrow,flagcol;
-  
-   Double_t epar;
-
-
-   npixel = 0;
-   xa = x1l;
-   za = z1l;
-   dx = TMath::Abs(x1l-x2l);
-   dz = TMath::Abs(z1l-z2l);
-   dtot = TMath::Sqrt((dx*dx)+(dz*dz));   
-   dm = (x2l - x1l) / (z2l - z1l);
-
-   dirx = (Int_t) ((x2l - x1l) / dx);
-   dirz = (Int_t) ((z2l - z1l) / dz);
-   
-   
-   // calculate the x coordinate of  the pixel in the next column    
-   // and the z coordinate of  the pixel in the next row    
-
-   Float_t xpos, zpos;
-
-   fSegmentation->GetPadCxz(c1, r1-1, xpos, zpos); 
-
-   Float_t xsize = fSegmentation->Dpx(0);
-   Float_t zsize = fSegmentation->Dpz(r1-1);
-
-   if (dirx == 1) refr = xpos+xsize/2.;
-             else refr = xpos-xsize/2.;
-
-   if (dirz == 1) refn = zpos+zsize/2.;
-             else refn = zpos-zsize/2.;
-
-   
-   flag = 0;
-   flagrow = 0;
-   flagcol = 0;
-   do
-   {
-       
-      // calculate the x coordinate of the intersection with the pixel
-      // in the next cell in row  direction
-
-      refm = (refn - z1l)*dm + x1l;
-   
-      // calculate the z coordinate of the intersection with the pixel
-      // in the next cell in column direction 
-
-      refc = (refr - x1l)/dm + z1l;
-      
-      
-      arefm = refm * dirx;
-      arefr = refr * dirx;
-      arefn = refn * dirz;
-      arefc = refc * dirz;
-            
-
-      if ((arefm < arefr) && (arefn < arefc)){
-        	 
-         // the track goes in the pixel in the next cell in row direction
-	     xb = refm;
-	     zb = refn;
-	     cb = c1;
-	     rb = r1 + dirz;
-	     azb = zb * dirz;
-         az2l = z2l * dirz;
-	     if (rb == r2) flagrow=1;
-	     if (azb > az2l) {
-	        zb = z2l;
-	        xb = x2l;
-	     }     
-
-         // shift to the pixel in the next cell in row direction
-         Float_t zsizeNext = fSegmentation->Dpz(rb-1);
-         //to account for cell at the borders of the detector
-         if(zsizeNext==0) zsizeNext = zsize;
-
-	     refn += zsizeNext*dirz;
-
-      }
-      else {
-         
-         // the track goes in the pixel in the next cell in column direction
-	     xb = refr;
-	     zb = refc;
-	     cb = c1 + dirx;
-	     rb = r1;
-	     axb = xb * dirx;
-         ax2l = x2l * dirx;
-         if (cb == c2) flagcol=1;
-	     if (axb > ax2l) {
-	        zb = z2l;
-	        xb = x2l;
-	     }
-
-         // shift to the pixel in the next cell in column direction
-         Float_t xsizeNext = fSegmentation->Dpx(cb-1);
-         //to account for cell at the borders of the detector
-         if(xsizeNext==0) xsizeNext = xsize;
-
-	     refr += xsizeNext*dirx;
-        
-      }
-      
-      //calculate the energy lost in the crossed pixel      
-      epar = TMath::Sqrt((xb-xa)*(xb-xa)+(zb-za)*(zb-za)); 
-      epar = etot*(epar/dtot);
-
-      //store row, column and energy lost in the crossed pixel
-      frowpixel[npixel] = r1;
-      fcolpixel[npixel] = c1;
-      fenepixel[npixel] = epar;
-      npixel++;
- 
-      // the exit point of the track is reached
-      if (epar == 0) flag = 1;
-      if ((r1 == r2) && (c1 == c2)) flag = 1;
-      if (flag!=1) {
-        r1 = rb;
-        c1 = cb;
-        xa = xb;
-        za = zb;
-      }
-   
-   } while (flag==0);
-
+//______________________________________________________________________
+void AliITSsimulationSPD::FrompListToDigits(){
+   // add noise and electronics, perform the zero suppression and add the
+   // digit to the list
+   // Inputs:
+   //    none.
+   // Outputs:
+   //    none.
+   // Return:
+   //    none.
+   static AliITS *aliITS = (AliITS*)gAlice->GetModule("ITS");
+   Int_t j,ix,iz;
+   Double_t  electronics;
+   Double_t sig;
+   const Int_t    knmaxtrk=AliITSdigit::GetNTracks();
+   static AliITSdigitSPD dig;
+   AliITSSimuParam *simpar = fDetType->GetSimuParam();
+   if(GetDebug(1)) Info("FrompListToDigits","()");
+   for(iz=0; izRndm() >= eff) continue;
+//        } // end  if 
+// END parametrize the efficiency
+// 
+       electronics = simpar->ApplySPDBaselineAndNoise();
+       UpdateMapNoise(ix,iz,electronics);
+       //
+       // Apply Threshold and write Digits.
+       sig = GetMap()->GetSignalOnly(iz,ix);
+       FillHistograms(ix,iz,sig+electronics);
+       if(GetDebug(3)){
+           cout<threshold("<GetNEntries()) {
+               dig.SetTrack(j,GetMap()->GetTrack(iz,ix,j));
+               dig.SetHit(j,GetMap()->GetHit(iz,ix,j));
+           }else { // Default values
+               dig.SetTrack(j,-3);
+               dig.SetHit(j,-1);
+           } // end if GetMap()
+       } // end for j
+       if(GetDebug(3)){
+           cout<GetpListItem(iz,ix))<AddSimDigit(0,&dig);
+       // simulate fo signal response for this pixel hit:
+       fDetType->ProcessSPDDigitForFastOr(fModule, dig.GetCoord1(), dig.GetCoord2());
+   } //  for ix/iz
+}
+//______________________________________________________________________
+void AliITSsimulationSPD::CreateHistograms(){
+   // create 1D histograms for tests
+   // Inputs:
+   //    none.
+   // Outputs:
+   //    none.
+   // Return:
+   //     none.
+
+   if(GetDebug(1)) Info("CreateHistograms","create histograms");
+
+   fHis = new TObjArray(GetNPixelsZ());
+   fSPDname="spd_";
+   for(Int_t i=0;iAddAt(new TH1F(fSPDname.Data(),"SPD maps",
+                            GetNPixelsX(),0.,(Double_t)GetNPixelsX()),i);
+   } // end for i
 }
-//___________________________________________________________________________
-void AliITSsimulationSPD::SetCoupling(Int_t row, Int_t col, Int_t ntrack,
-                                          Int_t idhit, Float_t **pList) {
-   //
+//______________________________________________________________________
+void AliITSsimulationSPD::FillHistograms(Int_t ix,Int_t iz,Double_t v){
+   // Fill the histogram
+   // Inputs:
+   //    none.
+   // Outputs:
+   //    none.
+   // Return:
+   //     none.
+
+   if(!GetHistArray()) return; // Only fill if setup.
+   if(GetDebug(2)) Info("FillHistograms","fill histograms");
+   GetHistogram(iz)->Fill(ix,v);
+}
+//______________________________________________________________________
+void AliITSsimulationSPD::ResetHistograms(){
+   // Reset histograms for this detector
+   // Inputs:
+   //    none.
+   // Outputs:
+   //    none.
+   // Return:
+   //     none.
+
+   if(!GetHistArray()) return; // Only fill if setup.
+   if(GetDebug(2)) Info("FillHistograms","fill histograms");
+   for ( int i=0;iAt(i))    ((TH1F*)fHis->At(i))->Reset();
+   } // end for i
+}
+
+//______________________________________________________________________
+void AliITSsimulationSPD::SetCoupling(Int_t col, Int_t row) {
    //  Take into account the coupling between adiacent pixels.
-   //  The parameters probcol and probrow are the fractions of the
+   //  The parameters probcol and probrow are the probability of the
    //  signal in one pixel shared in the two adjacent pixels along
    //  the column and row direction, respectively.
-   //
+   //  Note pList is goten via GetMap() and module is not need any more.
+   //  Otherwise it is identical to that coded by Tiziano Virgili (BSN).
    //Begin_Html
    /*
-   
-   
-
- - . - -
+     
+     
+
+ + . + +
    */
    //End_Html
-
-
+   // Inputs:
+   //    Int_t col            z cell index
+   //    Int_t row            x cell index
+   // Outputs:
+   //    none.
+   // Return:
+   //     none.
    Int_t j1,j2,flag=0;
    Double_t pulse1,pulse2;
-                              
-
-   j1 = row;
-   j2 = col;
-  
-   pulse1 = fMapA2->GetSignal(row,col);
+   Double_t couplR=0.0,couplC=0.0;
+   Double_t xr=0.;
+
+   GetCouplings(couplC,couplR);
+   if(GetDebug(3)) Info("SetCoupling","(col=%d,row=%d) "
+                        "Calling SetCoupling couplC=%e couplR=%e",
+                        col,row,couplC,couplR);
+   j1 = col;
+   j2 = row;
+   pulse1 = GetMap()->GetSignalOnly(col,row);
    pulse2 = pulse1;
-
-   for (Int_t isign=-1;isign<=1;isign+=2)
-   {
-
-// loop in row direction
-      
-      do
-      {
-         j1 += isign;
-         pulse1 *= fCouplRow;                  
-      
-         if ((j1 < 0) || (j1 > fNPixelsZ-1) || (pulse1 < fThresh))
-         { 
-	       pulse1 = fMapA2->GetSignal(row,col);
-	       j1 = row;
-	       flag = 1;
-         }
-          else{                
-		   UpdateMap(j1,col,pulse1);                   
-		   GetList(ntrack,idhit,pList,j1,col); 
-           flag = 0;
-	     }
-	 
-      } while(flag == 0);          
-      
-      
-// loop in column direction
-      
-      do
-      {
-         j2 += isign;
-         pulse2 *= fCouplCol;                  
-      
-         if ((j2 < 0) || (j2 > (fNPixelsX-1)) || (pulse2 < fThresh))
-         {                
-	       pulse2 = fMapA2->GetSignal(row,col);
-	       j2 = col;
-	       flag = 1;
-         }
-          else{                
-		   UpdateMap(row,j2,pulse2);                   
-		   GetList(ntrack,idhit,pList,row,j2); 
-           flag = 0;
-	     }
-	 
-      } while(flag == 0);          
-   
-   }
-
-}
-//___________________________________________________________________________
-void AliITSsimulationSPD::CreateDigit(Int_t nhits, Int_t module, Float_t
-**pList) {                                   
-  //
-  // The pixels are fired if the energy deposited inside them is above
-  // the threshold parameter ethr. Fired pixed are interpreted as digits
-  // and stored in the file digitfilename.
-  //
-
-   AliITS *aliITS  = (AliITS*)gAlice->GetModule("ITS");   
- 
-   
-   Int_t digits[3];
-   Int_t tracks[3];
-   Int_t hits[3];
-   Float_t charges[3]; 
-   Int_t gi,j1;
-   
-   if (nhits > 0) {
-    
-     for (Int_t r=1;r<=fNPixelsZ;r++) {
-        for (Int_t c=1;c<=fNPixelsX;c++) {
-   
-           // check if the deposited energy in a pixel is above the threshold 
-           Float_t signal = (Float_t) fMapA2->GetSignal(r,c);
-	   gi =r*fNPixelsX+c; // global index
-           if ( signal > fThresh) {
-	          digits[0] = r-1;  // digits starts from 0
-		  digits[1] = c-1;  // digits starts from 0
-		  //digits[2] = 1;  
-		  digits[2] =  (Int_t) signal;  // the signal is stored in electrons
-	          for(j1=0;j1<3;j1++){
-		    tracks[j1] = (Int_t)(*(pList[gi]+j1));
-		    hits[j1] = (Int_t)(*(pList[gi]+j1+6));
-		    charges[j1] = 0;
-		  }
-              /* debug
-              printf("digits %d %d %d\n",digits[0],digits[1],digits[2]); //debug
-              printf("tracks %d %d %d\n",tracks[0],tracks[1],tracks[2]); //debug
-              printf("hits %d %d %d\n",hits[0],hits[1],hits[2]); //debug
-              */
-              Float_t phys = 0;        
-	      aliITS->AddSimDigit(0,phys,digits,tracks,hits,charges);
-	   }//endif of threshold condition
-	   if(pList[gi]) delete [] pList[gi];
-        }
-     }// enddo on pixels
-    }
-    
+   for (Int_t isign=-1;isign<=1;isign+=2){// loop in col direction
+       do{
+           j1 += isign;
+           xr = gRandom->Rndm();
+           if ((j1<0) || (j1>GetNPixelsZ()-1) || (xr>couplC)){
+               j1 = col;
+               flag = 1;
+           }else{
+               UpdateMapNoise(row,j1,pulse1);
+               //  flag = 0;
+               flag = 1; // only first next!!
+           } // end if
+       } while(flag == 0);
+       // loop in row direction
+       do{
+           j2 += isign;
+           xr = gRandom->Rndm();
+           if ((j2<0) || (j2>GetNPixelsX()-1) || (xr>couplR)){
+               j2 = row;
+               flag = 1;
+           }else{
+               UpdateMapNoise(j2,col,pulse2);
+               //  flag = 0;
+               flag = 1; // only first next!!
+           } // end if
+       } while(flag == 0);
+   } // for isign
 }
-//_____________________________________________________________________________
-
-void AliITSsimulationSPD::GetList(Int_t label,Int_t idhit, Float_t **pList,
-                                      Int_t row, Int_t col) {
-  // loop over nonzero digits
-
-  Int_t ix = col;
-  Int_t iz = row;
-  Int_t globalIndex;
-  Float_t signal;
-  Float_t highest,middle,lowest;
-
-          
-  signal=fMapA2->GetSignal(iz,ix);
-
-
-  globalIndex = iz*fNPixelsX+ix; // globalIndex starts from 1
-
-
-  if(!pList[globalIndex])
-  {
-     // 
-     // Create new list (9 elements - 3 signals and 3 tracks + 3 hits)
-     //
-
-     pList[globalIndex] = new Float_t [9];
+//______________________________________________________________________
+void AliITSsimulationSPD::SetCouplingOld(Int_t col, Int_t row) {
+   //  Take into account the coupling between adiacent pixels.
+   //  The parameters probcol and probrow are the fractions of the
+   //  signal in one pixel shared in the two adjacent pixels along
+   //  the column and row direction, respectively.
+   //Begin_Html
+   /*
+     
+     
+
+ + . + +
+   */
+   //End_Html
+   // Inputs:
+   //    Int_t col            z cell index
+   //    Int_t row            x cell index
+   //    Int_t module         module number
+   // Outputs:
+   //    none.
+   // Return:
+   //     none.
+   Int_t j1,j2,flag=0;
+   Double_t pulse1,pulse2;
+   Double_t couplR=0.0,couplC=0.0;
 
+   GetCouplings(couplC,couplR);
 
-     // set list to -3 
-     *(pList[globalIndex]) = -3.;
-     *(pList[globalIndex]+1) = -3.;
-     *(pList[globalIndex]+2) = -3.;
-     *(pList[globalIndex]+3) =  0.;
-     *(pList[globalIndex]+4) =  0.;
-     *(pList[globalIndex]+5) =  0.;
-     *(pList[globalIndex]+6) = -1.;
-     *(pList[globalIndex]+7) = -1.;
-     *(pList[globalIndex]+8) = -1.;
+   //  Debugging ...
+//    cout << "Threshold --> " << GetThreshold() << endl;  // dom
+//    cout << "Couplings --> " << couplC << " " << couplR << endl;  // dom
 
-     *pList[globalIndex] = (float)label;
-     *(pList[globalIndex]+3) = signal;
-     *(pList[globalIndex]+6) = (float)idhit;
-  }
-  else{
-
-
-	  // check the signal magnitude
-      highest = *(pList[globalIndex]+3);
-      middle  = *(pList[globalIndex]+4);
-      lowest  = *(pList[globalIndex]+5);
-
-
-      signal -= (highest+middle+lowest);
-
-
-	  //
-	  //  compare the new signal with already existing list
-	  //
-      if(signalhighest)
-      {
-         *(pList[globalIndex]+8) = *(pList[globalIndex]+7);
-         *(pList[globalIndex]+7) = *(pList[globalIndex]+6);
-         *(pList[globalIndex]+6) = idhit;
-         *(pList[globalIndex]+5) = middle;
-         *(pList[globalIndex]+4) = highest;
-         *(pList[globalIndex]+3) = signal;
-         *(pList[globalIndex]+2) = *(pList[globalIndex]+1);
-         *(pList[globalIndex]+1) = *pList[globalIndex];
-         *(pList[globalIndex]) = label;
-	  }
-        else if (signal>middle)
-      {
-         *(pList[globalIndex]+8) = *(pList[globalIndex]+7);
-         *(pList[globalIndex]+7) = idhit;
-         *(pList[globalIndex]+5) = middle;
-         *(pList[globalIndex]+4) = signal;
-         *(pList[globalIndex]+2) = *(pList[globalIndex]+1);
-         *(pList[globalIndex]+1) = label;
-	  }
-        else
-      {
-         *(pList[globalIndex]+8) = idhit;
-         *(pList[globalIndex]+5) = signal;
-         *(pList[globalIndex]+2) = label;
-	  }
-  }    
+   if(GetDebug(3)) Info("SetCouplingOld","(col=%d,row=%d) "
+                        "Calling SetCoupling couplC=%e couplR=%e",
+                        col,row,couplC,couplR);
+   for (Int_t isign=-1;isign<=1;isign+=2){// loop in col direction
+   pulse1 = GetMap()->GetSignalOnly(col,row);
+   pulse2 = pulse1;
+   j1 = col;
+   j2 = row;
+       do{
+           j1 += isign;
+           pulse1 *= couplC;
+           if ((j1<0)||(j1>GetNPixelsZ()-1)||(pulse1GetSignalOnly(col,row);
+               j1 = col;
+               flag = 1;
+           }else{
+               UpdateMapNoise(row,j1,pulse1);
+               // flag = 0;
+               flag = 1;  // only first next !!
+           } // end if
+       } while(flag == 0);
+       // loop in row direction
+       do{
+           j2 += isign;
+           pulse2 *= couplR;
+           if((j2<0)||(j2>(GetNPixelsX()-1))||(pulse2GetSignalOnly(col,row);
+               j2 = row;
+               flag = 1;
+           }else{
+               UpdateMapNoise(j2,col,pulse2);
+               // flag = 0;
+               flag = 1; // only first next!!
+           } // end if
+       } while(flag == 0);
+   } // for isign
 }
-//_________________________________________________________________________ 
-void AliITSsimulationSPD::SetFluctuations(Float_t **pList) {
-  //
-  //  Set the electronic noise and threshold non-uniformities to all the
-  //  pixels in a detector.
-  //  The parameter fSigma is the squared sum of the sigma due to noise
-  //  and the sigma of the threshold distribution among pixels.
-  //
-  //Begin_Html
-  /*
-  
-  
-
- - . - -
-  */
-  //End_Html
-  
-  
-  Double_t signal;
-
-  Int_t iz,ix;
-  for(iz=1;iz<=fNPixelsZ;iz++){
-    for(ix=1;ix<=fNPixelsX;ix++){
-      signal = fSigma*gRandom->Gaus(); 
-      fMapA2->SetHit(iz,ix,signal);
-
-      // insert in the label-signal-hit list the pixels fired only by noise
-      if ( signal > fThresh) {
-        Int_t globalIndex = iz*fNPixelsX+ix; 
-        pList[globalIndex] = new Float_t [9];
-        *(pList[globalIndex]) = -2.;
-        *(pList[globalIndex]+1) = -2.;
-        *(pList[globalIndex]+2) = -2.;
-        *(pList[globalIndex]+3) =  signal;
-        *(pList[globalIndex]+4) =  0.;
-        *(pList[globalIndex]+5) =  0.;
-        *(pList[globalIndex]+6) =  -1.;
-        *(pList[globalIndex]+7) =  -1.;
-        *(pList[globalIndex]+8) =  -1.;
-      }
-    } // end of loop on pixels
-  } // end of loop on pixels
-  
- }
-//____________________________________________
-
-void AliITSsimulationSPD::CreateHistograms() {
-  // CreateHistograms
-
-      Int_t i;
-      fHis=new TObjArray(fNPixelsZ);
-      for(i=0;iInteger(fStrobeLenght))*kBunchLenght-
+                  (Double_t)fStrobeLenght*kBunchLenght+
+                  kBunchLenght/2;
 }
 
-//____________________________________________
-
-void AliITSsimulationSPD::ResetHistograms() {
-    //
-    // Reset histograms for this detector
-    //
-    Int_t i;
-    for(i=0;iReset();
-    }
-
-}