* about the suitability of this software for any purpose. It is *
* provided "as is" without express or implied warranty. *
**************************************************************************/
+/*
+ $Id$
+ $Log$
+ Revision 1.37 2002/10/14 14:57:07 hristov
+ Merging the VirtualMC branch to the main development branch (HEAD)
+
+ Revision 1.32.4.4 2002/10/14 13:14:08 hristov
+ Updating VirtualMC to v3-09-02
+
+ Revision 1.36 2002/09/11 10:32:41 hristov
+ Use new for arrays with variable size
+
+ Revision 1.35 2002/09/09 17:23:28 nilsen
+ Minor changes in support of changes to AliITSdigitS?D class'.
+
+ Revision 1.34 2002/06/07 16:32:28 nilsen
+ Latest SDD changes to speed up the SDD simulation code.
-#include <iostream.h>
+ Revision 1.33 2002/04/24 22:02:31 nilsen
+ New SDigits and Digits routines, and related changes, (including new
+ noise values).
+
+ */
+
+#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();
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 idx, az;
- Int_t maxIndex = fpList->GetMaxIndex();
- for( Int_t i=0; i<maxIndex; i++ ) {
- fpList->GetMapIndex( i, az, idx );
- fHitMap2->SetHit( az, idx, fpList->GetSignal( az, idx ) );
- } // end for 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 );
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::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));
//______________________________________________________________________
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