* provided "as is" without express or implied warranty. *
**************************************************************************/
-#include <iostream.h>
+/* $Id$ */
+
+#include <Riostream.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
fHis = 0;
// fpList = 0;
fHitMap2 = 0;
+ fHitSigMap2 = 0;
+ fHitNoiMap2 = 0;
fElectronics = 0;
fStream = 0;
fInZR = 0;
fMaxNofSamples = 0;
fITS = 0;
fTreeB = 0;
+ fAnodeFire = 0;
SetScaleFourier();
SetPerpendTracksFlag();
SetCrosstalkFlag();
SetCheckNoise();
}
//______________________________________________________________________
-AliITSsimulationSDD::AliITSsimulationSDD(AliITSsimulationSDD &source){
+AliITSsimulationSDD::AliITSsimulationSDD(AliITSsimulationSDD &source) :
+ AliITSsimulation(source){
// Copy constructor to satify Coding roules only.
if(this==&source) return;
fHis = 0;
// fpList = 0;
fHitMap2 = 0;
+ fHitSigMap2 = 0;
+ fHitNoiMap2 = 0;
fElectronics = 0;
fStream = 0;
fInZR = 0;
fpList = new AliITSpList( fSegmentation->Npz(),
fScaleSize*fSegmentation->Npx() );
- fHitMap2 = new AliITSMapA2(fSegmentation,fScaleSize,1);
+ fHitSigMap2 = new AliITSMapA2(fSegmentation,fScaleSize,1);
+ fHitNoiMap2 = new AliITSMapA2(fSegmentation,fScaleSize,1);
+ fHitMap2 = fHitSigMap2;
fNofMaps = fSegmentation->Npz();
fMaxNofSamples = fSegmentation->Npx();
-
+ fAnodeFire = new Bool_t [fNofMaps];
+
Float_t sddLength = fSegmentation->Dx();
Float_t sddWidth = fSegmentation->Dz();
} // end if
const char *kopt=fResponse->ZeroSuppOption();
- if (strstr(fParam,"file") ) {
+ if (strstr(fParam.Data(),"file") ) {
fD.Set(fNofMaps);
fT1.Set(fNofMaps);
if (strstr(kopt,"2D")) {
// destructor
// delete fpList;
- delete fHitMap2;
+ delete fHitSigMap2;
+ delete fHitNoiMap2;
delete fStream;
delete fElectronics;
if(fInZI) delete [] fInZI;
if(fOutZR) delete [] fOutZR;
if(fOutZI) delete [] fOutZI;
+ if(fAnodeFire) delete [] fAnodeFire;
}
//______________________________________________________________________
void AliITSsimulationSDD::InitSimulationModule( Int_t module, Int_t event ) {
fModule = module;
fEvent = event;
ClearMaps();
+ memset(fAnodeFire,0,sizeof(Bool_t)*fNofMaps);
}
//______________________________________________________________________
void AliITSsimulationSDD::ClearMaps() {
// clear maps
fpList->ClearMap();
- fHitMap2->ClearMap();
+ fHitSigMap2->ClearMap();
+ fHitNoiMap2->ClearMap();
}
//______________________________________________________________________
void AliITSsimulationSDD::SDigitiseModule( AliITSmodule *mod, Int_t md, Int_t ev){
InitSimulationModule( md, ev );
HitsToAnalogDigits( mod );
+ ChargeToSignal( kFALSE ); // - Process signal without add noise
+ fHitMap2 = fHitNoiMap2; // - Swap to noise map
+ ChargeToSignal( kTRUE ); // - Process only noise
+ fHitMap2 = fHitSigMap2; // - Return to signal map
WriteSDigits();
ClearMaps();
}
//______________________________________________________________________
-/*void AliITSsimulationSDD::AddSDigitsToModule( TClonesArray *pItemArray, Int_t mask ) {
+Bool_t AliITSsimulationSDD::AddSDigitsToModule( TClonesArray *pItemArray, Int_t mask ) {
// Add Summable digits to module maps.
- Int_t nItems = pItemArray->GetEntries();
-
+ Int_t nItems = pItemArray->GetEntries();
+ Double_t maxadc = fResponse->MaxAdc();
+ //Bool_t sig = kFALSE;
+
// cout << "Adding "<< nItems <<" SDigits to module " << fModule << endl;
for( Int_t i=0; i<nItems; i++ ) {
AliITSpListItem * pItem = (AliITSpListItem *)(pItemArray->At( i ));
Error( "AliITSsimulationSDD",
"Error reading, SDigits module %d != current module %d: exit\n",
pItem->GetModule(), fModule );
- return;
+ return kFALSE;
} // end if
+
+ // if(pItem->GetSignal()>0.0 ) sig = kTRUE;
- fpList->AddItemTo( mask, pItem );
+ fpList->AddItemTo( mask, pItem ); // Add SignalAfterElect + noise
+ AliITSpListItem * pItem2 = fpList->GetpListItem( pItem->GetIndex() );
+ Double_t sigAE = pItem2->GetSignalAfterElect();
+ if( sigAE >= maxadc ) sigAE = maxadc-1; // avoid overflow signal
+ Int_t ia;
+ Int_t it;
+ fpList->GetMapIndex( pItem->GetIndex(), ia, it );
+ fHitMap2->SetHit( ia, it, sigAE );
+ fAnodeFire[ia] = kTRUE;
}
-}*/
+ return kTRUE;
+}
//______________________________________________________________________
void AliITSsimulationSDD::FinishSDigitiseModule() {
// digitize module using the "slow" detector simulator from
InitSimulationModule( md, ev );
if( !nhits && fCheckNoise ) {
- ChargeToSignal();
+ ChargeToSignal( kTRUE ); // process noise
GetNoise();
ClearMaps();
return;
} else
if( !nhits ) return;
+
HitsToAnalogDigits( mod );
+ ChargeToSignal( kTRUE ); // process signal + noise
+
+ for( Int_t i=0; i<fNofMaps; i++ ) {
+ for( Int_t j=0; j<fMaxNofSamples; j++ ) {
+ Int_t jdx = j*fScaleSize;
+ Int_t index = fpList->GetHitIndex( i, j );
+ AliITSpListItem pItemTmp2( fModule, index, 0. );
+ // put the fScaleSize analog digits in only one
+ for( Int_t ik=0; ik<fScaleSize; ik++ ) {
+ AliITSpListItem *pItemTmp = fpList->GetpListItem( i, jdx+ik );
+ if( pItemTmp == 0 ) continue;
+ pItemTmp2.Add( pItemTmp );
+ }
+ fpList->DeleteHit( i, j );
+ fpList->AddItemTo( 0, &pItemTmp2 );
+ }
+ }
+
FinishDigits();
ClearMaps();
}
void AliITSsimulationSDD::FinishDigits() {
// introduce the electronics effects and do zero-suppression if required
- // Fill maps from fpList.
- Int_t maxIndex = fpList->GetEntries();
- for(Int_t i=0;i<maxIndex;i++) fHitMap2->SetHit(i,fpList->GetSignal(i));
-
- ChargeToSignal();
ApplyDeadChannels();
if( fCrosstalkFlag ) ApplyCrosstalk();
Double_t eVpairs = 3.6; // electron pair energy eV.
Float_t nsigma = fResponse->NSigmaIntegration(); //
Int_t nlookups = fResponse->GausNLookUp(); //
+ Float_t jitter = ((AliITSresponseSDD*)fResponse)->JitterError(); //
// Piergiorgio's part (apart for few variables which I made float
// when i thought that can be done
for(ii=0; ii<nhits; ii++) {
if(!mod->LineSegmentL(ii,xL[0],dxL[0],xL[1],dxL[1],xL[2],dxL[2],
depEnergy,itrack)) continue;
+ xL[0] += 0.0001*gRandom->Gaus( 0, jitter ); //
depEnergy *= kconv;
hitDetector = mod->GetDet();
//tof = 1.E+09*(mod->GetHit(ii)->GetTOF()); // tof in ns.
timeAmplitude *= norm;
timeAmplitude *= 10;
// ListOfFiredCells(arg,timeAmplitude,alst,padr);
+ Double_t charge = timeAmplitude;
+ charge += fHitMap2->GetSignal(index,it-1);
+ fHitMap2->SetHit(index, it-1, charge);
fpList->AddSignal(index,it-1,itrack,ii-1,
mod->GetIndex(),timeAmplitude);
+ fAnodeFire[index] = kTRUE;
} // end if anodeAmplitude and loop over time in window
} // loop over anodes in window
} // end loop over "sub-hits"
//____________________________________________
void AliITSsimulationSDD::AddDigit( Int_t i, Int_t j, Int_t signal ) {
// Adds a Digit.
- Int_t digits[3], tracks[3], hits[3];
- Float_t phys, charges[3];
+ Int_t size = AliITSdigitSPD::GetNTracks();
+ Int_t digits[3];
+ Int_t * tracks = new Int_t[size];
+ Int_t * hits = new Int_t[size];
+ Float_t phys;
+ Float_t * charges = new Float_t[size];
- if( fResponse->Do10to8() ) signal = Convert8to10( signal );
+// if( fResponse->Do10to8() ) signal = Convert8to10( signal );
digits[0] = i;
digits[1] = j;
digits[2] = signal;
- Int_t jdx = j*fScaleSize;
- AliITSpListItem pItem;
-
- // put the fScaleSize analog digits in only one
- for( Int_t ik=0; ik<fScaleSize; ik++ ) {
- AliITSpListItem* pItemTmp = fpList->GetpListItem( i, jdx+ik );
- if( pItemTmp == 0 ) continue;
- Double_t sig = 0.0;
- for( Int_t l=0; l<pItemTmp->GetNsignals(); l++ ) {
- Double_t signalT = pItemTmp->GetSignal( l );
- // if( signalT <= 0.0 ) break; // no more signals
- sig += signalT;
- Int_t track = pItemTmp->GetTrack( l );
- Int_t hit = pItemTmp->GetHit( l );
- pItem.AddSignal( track, hit, -1, -1, signalT );
+ AliITSpListItem *pItem = fpList->GetpListItem( i, j );
+ if( pItem == 0 ) {
+ phys = 0.0;
+ for( Int_t l=0; l<size; l++ ) {
+ tracks[l] = 0;
+ hits[l] = 0;
+ charges[l] = 0.0;
}
- // add to noise : total signal - sum of signal tracks
- pItem.AddNoise( -1, -1, pItemTmp->GetSignal() - sig );
- }
-
- Int_t idtrack = pItem.GetTrack( 0 );
- if( idtrack >= 0 ) phys = pItem.GetSumSignal();
- else phys = 0;
-
- for( Int_t l=0; l<3; l++ ) {
- tracks[l] = pItem.GetTrack( l );
- hits[l] = pItem.GetHit( l );
- charges[l] = pItem.GetSignal( l );
+ } else {
+ Int_t idtrack = pItem->GetTrack( 0 );
+ if( idtrack >= 0 ) phys = pItem->GetSignal();
+ else phys = 0.0;
+
+ for( Int_t l=0; l<size; l++ ) if(l<pItem->GetMaxKept()) {
+ tracks[l] = pItem->GetTrack( l );
+ hits[l] = pItem->GetHit( l );
+ charges[l] = pItem->GetSignal( l );
+ }else{
+ tracks[l] = -3;
+ hits[l] = -1;
+ charges[l] = 0.0;
+ }// end for if
}
fITS->AddSimDigit( 1, phys, digits, tracks, hits, charges );
+ delete [] tracks;
+ delete [] hits;
+ delete [] charges;
}
-/*
-//____________________________________________
-void AliITSsimulationSDD::AddDigit(Int_t i, Int_t j, Int_t signal){
- // Adds a Digit.
- // tag with -1 signals coming from background tracks
- // tag with -2 signals coming from pure electronic noise
-
- Int_t digits[3], tracks[3], hits[3];
- Float_t phys, charges[3];
-
- Int_t trk[20], htrk[20];
- Float_t chtrk[20];
-
- Bool_t do10to8=fResponse->Do10to8();
-
- if(do10to8) signal=Convert8to10(signal);
- AliITSTransientDigit *obj = (AliITSTransientDigit*)fHitMap1->GetHit(i,j);
- digits[0] = i;
- digits[1] = j;
- digits[2] = signal;
- if (!obj) {
- phys=0;
- Int_t k;
- for (k=0;k<3;k++) {
- tracks[k]=-2;
- charges[k]=0;
- hits[k]=-1;
- } // end for k
- fITS->AddSimDigit(1,phys,digits,tracks,hits,charges);
- } else {
- phys=obj->fPhysics;
- TObjArray* trlist=(TObjArray*)obj->TrackList();
- Int_t nptracks=trlist->GetEntriesFast();
- if (nptracks > 20) {
- Warning("AddDigit","nptracks=%d > 20 nptracks set to 20",nptracks);
- nptracks=20;
- } // end if nptracks > 20
- Int_t tr;
- for (tr=0;tr<nptracks;tr++) {
- TVector &pp =*((TVector*)trlist->At(tr));
- trk[tr]=Int_t(pp(0));
- htrk[tr]=Int_t(pp(1));
- chtrk[tr]=(pp(2));
- } // end for tr
- if (nptracks > 1) {
- SortTracks(trk,chtrk,htrk,nptracks);
- } // end if nptracks > 1
- Int_t i;
- if (nptracks < 3 ) {
- for (i=0; i<nptracks; i++) {
- tracks[i]=trk[i];
- charges[i]=chtrk[i];
- hits[i]=htrk[i];
- } // end for i
- for (i=nptracks; i<3; i++) {
- tracks[i]=-3;
- hits[i]=-1;
- charges[i]=0;
- } // end for i
- } else {
- for (i=0; i<3; i++) {
- tracks[i]=trk[i];
- charges[i]=chtrk[i];
- hits[i]=htrk[i];
- } // end for i
- } // end if/else nptracks < 3
-
- fITS->AddSimDigit(1,phys,digits,tracks,hits,charges);
-
- } // end if/else !obj
-}
-
-
//______________________________________________________________________
-void AliITSsimulationSDD::SortTracks(Int_t *tracks,Float_t *charges,
- Int_t *hits,Int_t ntr){
- // Sort the list of tracks contributing to a given digit
- // Only the 3 most significant tracks are acctually sorted
- // Loop over signals, only 3 times
-
- Float_t qmax;
- Int_t jmax;
- Int_t idx[3] = {-3,-3,-3};
- Float_t jch[3] = {-3,-3,-3};
- Int_t jtr[3] = {-3,-3,-3};
- Int_t jhit[3] = {-3,-3,-3};
- Int_t i,j,imax;
-
- if (ntr<3) imax = ntr;
- else imax = 3;
- for(i=0;i<imax;i++){
- qmax = 0;
- jmax = 0;
- for(j=0;j<ntr;j++){
- if((i == 1 && j == idx[i-1] )
- ||(i == 2 && (j == idx[i-1] || j == idx[i-2]))) continue;
- if(charges[j] > qmax) {
- qmax = charges[j];
- jmax=j;
- } // end if charges[j]>qmax
- } // end for j
- if(qmax > 0) {
- idx[i] = jmax;
- jch[i] = charges[jmax];
- jtr[i] = tracks[jmax];
- jhit[i] = hits[jmax];
- } // end if qmax > 0
- } // end for i
-
- for(i=0;i<3;i++){
- if (jtr[i] == -3) {
- charges[i] = 0;
- tracks[i] = -3;
- hits[i] = -1;
- } else {
- charges[i] = jch[i];
- tracks[i] = jtr[i];
- hits[i] = jhit[i];
- } // end if jtr[i] == -3
- } // end for i
-}
-*/
-//______________________________________________________________________
-void AliITSsimulationSDD::ChargeToSignal() {
+void AliITSsimulationSDD::ChargeToSignal(Bool_t bAddNoise) {
// add baseline, noise, electronics and ADC saturation effects
char opt1[20], opt2[20];
Float_t maxadc = fResponse->MaxAdc();
if(!fDoFFT) {
for (i=0;i<fNofMaps;i++) {
+ if( !fAnodeFire[i] ) continue;
if (read && i<fNofMaps) GetAnodeBaseline(i,baseline,noise);
for(k=0; k<fScaleSize*fMaxNofSamples; k++) {
fInZR[k] = fHitMap2->GetSignal(i,k);
- contrib = (baseline + noise*gRandom->Gaus());
- fInZR[k] += contrib;
+ if( bAddNoise ) {
+ contrib = (baseline + noise*gRandom->Gaus());
+ fInZR[k] += contrib;
+ }
} // end for k
for(k=0; k<fMaxNofSamples; k++) {
Double_t newcont = 0.;
} // end if DoFFT
for (i=0;i<fNofMaps;i++) {
+ if( !fAnodeFire[i] ) continue;
if (read && i<fNofMaps) GetAnodeBaseline(i,baseline,noise);
for(k=0; k<fScaleSize*fMaxNofSamples; k++) {
fInZR[k] = fHitMap2->GetSignal(i,k);
- contrib = (baseline + noise*gRandom->Gaus());
- fInZR[k] += contrib;
+ if( bAddNoise ) {
+ contrib = (baseline + noise*gRandom->Gaus());
+ fInZR[k] += contrib;
+ }
fInZI[k] = 0.;
} // end for k
FastFourierTransform(fElectronics,&fInZR[0],&fInZI[0],1);
else return (256+((signal-192)<<3)+4);
} // end if signal < 224
if (TMath::Odd(signal)) return (512+((signal-224)<<4)+7);
- return (512+((signal-224)<<4)+7);
+ return (512+((signal-224)<<4)+8);
}
/*
// Albert W.) :
// Read 2D zero-suppression parameters for SDD
- if (!strstr(fParam,"file")) return;
+ if (!strstr(fParam.Data(),"file")) return;
Int_t na,pos,tempTh;
Float_t mu,sigma;
// Torino people should give input
// Read 1D zero-suppression parameters for SDD
- if (!strstr(fParam,"file")) return;
+ if (!strstr(fParam.Data(),"file")) return;
Int_t na,pos,tempTh;
Float_t mu,sigma;
for (i=0; i<fNofMaps/2; i++) {
Bool_t firstSignal=kTRUE;
Int_t idx=i+k*fNofMaps/2;
+ if( !fAnodeFire[idx] ) continue;
CompressionParam(idx,decr,thres);
for (j=0; j<fMaxNofSamples; j++) {
Int_t signal=(Int_t)(fHitMap2->GetSignal(idx,j));
// this if(TMath::Abs(diff)<tol) ... else ...
if(TMath::Abs(diff)<tol) diff=0;
// or keep it as it was before
- /*
- if (tol==1 && (diff >= -2 && diff <= 1)) diff=0;
- if (tol==2 && (diff >= -4 && diff <= 3)) diff=0;
- if (tol==3 && (diff >= -16 && diff <= 15)) diff=0;
- */
AddDigit(idx,j,last+diff);
} else {
AddDigit(idx,j,signal);
//______________________________________________________________________
void AliITSsimulationSDD::WriteSDigits(){
// Fills the Summable digits Tree
- Int_t i,ni,j,nj;
static AliITS *aliITS = (AliITS*)gAlice->GetModule("ITS");
- fpList->GetMaxMapIndex( ni, nj );
- for( i=0; i<ni; i++ )
- for( j=0; j<nj; j++ ) {
-// if( fpList->GetSignalOnly( i, j ) > 0.5*fT1[0] ) {
- if( fpList->GetpListItem( i, j ) != 0 )
- // above small threshold.
- aliITS->AddSumDigit( *(fpList->GetpListItem( i, j ) ) );
-// cout << "pListSDD: " << *(pList->GetpListItem(i,j)) << endl;
-// } // end if
- } // end for i,j
+ for( Int_t i=0; i<fNofMaps; i++ ) {
+ if( !fAnodeFire[i] ) continue;
+ for( Int_t j=0; j<fMaxNofSamples; j++ ) {
+ Double_t sig = fHitMap2->GetSignal( i, j );
+ if( sig > 0.2 ) {
+ Int_t jdx = j*fScaleSize;
+ Int_t index = fpList->GetHitIndex( i, j );
+ AliITSpListItem pItemTmp2( fModule, index, 0. );
+ // put the fScaleSize analog digits in only one
+ for( Int_t ik=0; ik<fScaleSize; ik++ ) {
+ AliITSpListItem *pItemTmp = fpList->GetpListItem( i, jdx+ik );
+ if( pItemTmp == 0 ) continue;
+ pItemTmp2.Add( pItemTmp );
+ }
+ pItemTmp2.AddSignalAfterElect( fModule, index, sig );
+ pItemTmp2.AddNoise( fModule, index, fHitNoiMap2->GetSignal( i, j ) );
+ aliITS->AddSumDigit( pItemTmp2 );
+ } // end if (sig > 0.2)
+ }
+ }
return;
}
//______________________________________________________________________
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff