#include <TF1.h>
#include <TH1.h>
#include <TFile.h>
-
+#include <TRandom.h>
+#include <TROOT.h>
#include "AliITS.h"
#include "AliITSMapA2.h"
#include "AliITSRawData.h"
#include "AliITSdigitSPD.h"
#include "AliITSetfSDD.h"
-#include "AliITSgeom.h"
#include "AliITSmodule.h"
#include "AliITSpList.h"
#include "AliITSresponseSDD.h"
fHis(0),
fD(),
fT1(),
+fT2(),
fTol(),
-fBaseline(),
-fNoise(),
fTreeB(0),
+fParam(0),
fFileName(),
fFlag(kFALSE),
fCheckNoise(kFALSE),
SetCheckNoise();
}
//______________________________________________________________________
-AliITSsimulationSDD::AliITSsimulationSDD(AliITSsimulationSDD &source) :
- AliITSsimulation(source){
+AliITSsimulationSDD::AliITSsimulationSDD(const AliITSsimulationSDD &source) :
+ AliITSsimulation(source),
+fITS(source.fITS),
+fHitMap2(source.fHitMap2),
+fHitSigMap2(source.fHitSigMap2),
+fHitNoiMap2(source.fHitNoiMap2),
+fStream(source.fStream),
+fElectronics(source.fElectronics),
+fInZR(source.fInZR),
+fInZI(source.fInZI),
+fOutZR(source.fOutZR),
+fOutZI(source.fOutZI),
+fAnodeFire(source.fAnodeFire),
+fHis(source.fHis),
+fD(source.fD),
+fT1(source.fT1),
+fT2(source.fT2),
+fTol(source.fTol),
+fTreeB(source.fTreeB),
+fParam(source.fParam),
+fFileName(source.fFileName),
+fFlag(source.fFlag),
+fCheckNoise(source.fCheckNoise),
+fCrosstalkFlag(source.fCrosstalkFlag),
+fDoFFT(source.fDoFFT),
+fNofMaps(source.fNofMaps),
+fMaxNofSamples(source.fMaxNofSamples),
+fScaleSize(source.fScaleSize){
// Copy constructor to satify Coding roules only.
- if(this==&source) return;
- Error("AliITSsimulationSDD","Not allowed to make a copy of "
- "AliITSsimulationSDD Using default creater instead");
- AliITSsimulationSDD();
}
//______________________________________________________________________
AliITSsimulationSDD& AliITSsimulationSDD::operator=(const AliITSsimulationSDD &src){
fHis(0),
fD(),
fT1(),
+fT2(),
fTol(),
-fBaseline(),
-fNoise(),
fTreeB(0),
+fParam(),
fFileName(),
fFlag(kFALSE),
fCheckNoise(kFALSE),
fNofMaps(0),
fMaxNofSamples(0),
fScaleSize(0){
- // Standard Constructor
-
- Init();
+ // Default Constructor
+ Init();
}
//______________________________________________________________________
void AliITSsimulationSDD::Init(){
AliITSsegmentationSDD* seg = (AliITSsegmentationSDD*)GetSegmentationModel(1);
- AliITSCalibrationSDD* res = (AliITSCalibrationSDD*)GetCalibrationModel(fDetType->GetITSgeom()->GetStartSDD());
+ AliITSresponseSDD* res = (AliITSresponseSDD*)fDetType->GetResponse(1);
fpList = new AliITSpList( seg->Npz(),
fScaleSize*seg->Npx() );
fHitSigMap2 = new AliITSMapA2(seg,fScaleSize,1);
Int_t dummy = 0;
Float_t anodePitch = seg->Dpz(dummy);
Double_t timeStep = (Double_t)seg->Dpx(dummy);
- Float_t driftSpeed = res->GetDriftSpeed();
+ Float_t driftSpeed = res->DriftSpeed();
if(anodePitch*(fNofMaps/2) > sddWidth) {
Warning("AliITSsimulationSDD",
} // end if
fElectronics = new AliITSetfSDD(timeStep/fScaleSize,
- res->GetElectronics());
+ res->Electronics());
char opt1[20], opt2[20];
- res->GetParamOptions(opt1,opt2);
+ res->ParamOptions(opt1,opt2);
fParam = opt2;
- char *same = strstr(opt1,"same");
- if (same) {
- fNoise.Set(0);
- fBaseline.Set(0);
- } else {
- fNoise.Set(fNofMaps);
- fBaseline.Set(fNofMaps);
- } // end if
-
- const char *kopt=res->GetZeroSuppOption();
- if (strstr(fParam.Data(),"file") ) {
- fD.Set(fNofMaps);
- fT1.Set(fNofMaps);
- if (strstr(kopt,"2D")) {
- fT2.Set(fNofMaps);
- fTol.Set(0);
- Init2D(); // desactivate if param change module by module
- } else if(strstr(kopt,"1D")) {
- fT2.Set(2);
- fTol.Set(2);
- Init1D(); // desactivate if param change module by module
- } // end if strstr
- } else {
- fD.Set(2);
- fTol.Set(2);
- fT1.Set(2);
- fT2.Set(2);
- SetCompressParam();
- } // end if else strstr
+ const char *kopt=res->ZeroSuppOption();
+ fD.Set(fNofMaps);
+ fT1.Set(fNofMaps);
+ fT2.Set(fNofMaps);
+ fTol.Set(fNofMaps);
+
Bool_t write = res->OutputOption();
if(write && strstr(kopt,"2D")) MakeTreeB();
-
- // call here if baseline does not change by module
- // ReadBaseline();
-
+
fITS = (AliITS*)gAlice->GetModule("ITS");
Int_t size = fNofMaps*fMaxNofSamples;
fStream = new AliITSInStream(size);
Bool_t AliITSsimulationSDD::AddSDigitsToModule(TClonesArray *pItemArray,
Int_t mask ) {
// Add Summable digits to module maps.
- AliITSCalibrationSDD* res = (AliITSCalibrationSDD*)GetCalibrationModel(fDetType->GetITSgeom()->GetStartSDD());
+ AliITSresponseSDD* res = (AliITSresponseSDD*)fDetType->GetResponse(1);
Int_t nItems = pItemArray->GetEntries();
- Double_t maxadc = res->GetMaxAdc();
+ Double_t maxadc = res->MaxAdc();
Bool_t sig = kFALSE;
// cout << "Adding "<< nItems <<" SDigits to module " << fModule << endl;
ApplyDeadChannels(fModule);
if( fCrosstalkFlag ) ApplyCrosstalk(fModule);
- AliITSCalibrationSDD* res = (AliITSCalibrationSDD*)GetCalibrationModel(fDetType->GetITSgeom()->GetStartSDD());
+ AliITSCalibrationSDD* res = (AliITSCalibrationSDD*)GetCalibrationModel(fModule);
const char *kopt = res->GetZeroSuppOption();
ZeroSuppression( kopt );
}
// create maps to build the lists of tracks for each digit
AliITSsegmentationSDD* seg = (AliITSsegmentationSDD*)GetSegmentationModel(1);
- AliITSCalibrationSDD* res = (AliITSCalibrationSDD*)GetCalibrationModel(fDetType->GetITSgeom()->GetStartSDD());
+ AliITSCalibrationSDD* res = (AliITSCalibrationSDD*)GetCalibrationModel(fModule);
TObjArray *hits = mod->GetHits();
Int_t nhits = hits->GetEntriesFast();
// Int_t arg[6] = {0,0,0,0,0,0};
- Int_t dummy = 0;
- Int_t nofAnodes = fNofMaps/2;
- Float_t sddLength = seg->Dx();
- Float_t sddWidth = seg->Dz();
- Float_t anodePitch = seg->Dpz(dummy);
- Float_t timeStep = seg->Dpx(dummy);
- Float_t driftSpeed = res->GetDriftSpeed();
- Float_t maxadc = res->GetMaxAdc();
- Float_t topValue = res->GetDynamicRange();
- Float_t cHloss = res->GetChargeLoss();
- Float_t norm = maxadc/topValue;
- Float_t dfCoeff, s1; res->DiffCoeff(dfCoeff,s1); // Signal 2d Shape
- Double_t eVpairs = res->GetGeVToCharge()*1.0E9; // 3.6 eV by def.
- Float_t nsigma = res->GetNSigmaIntegration(); //
- Int_t nlookups = res->GetGausNLookUp(); //
- Float_t jitter = res->GetJitterError(); //
+ Int_t dummy = 0;
+ Int_t nofAnodes = fNofMaps/2;
+ Double_t sddLength = seg->Dx();
+ Double_t sddWidth = seg->Dz();
+ Double_t anodePitch = seg->Dpz(dummy);
+ Double_t timeStep = seg->Dpx(dummy);
+ Double_t driftSpeed = res->GetDriftSpeed();
+ //Float_t maxadc = res->GetMaxAdc();
+ //Float_t topValue = res->GetDynamicRange();
+ Double_t norm = res->GetMaxAdc()/res->GetDynamicRange(); // maxadc/topValue;
+ Double_t cHloss = res->GetChargeLoss();
+ Float_t dfCoeff, s1; res->DiffCoeff(dfCoeff,s1); // Signal 2d Shape
+ Double_t eVpairs = res->GetGeVToCharge()*1.0E9; // 3.6 eV by def.
+ Double_t nsigma = res->GetNSigmaIntegration(); //
+ Int_t nlookups = res->GetGausNLookUp(); //
+ Float_t jitter = res->GetJitterError(); //
// Piergiorgio's part (apart for few variables which I made float
// when i thought that can be done
// loop over hits in the module
const Float_t kconv = 1.0e+6; // GeV->KeV
- Int_t itrack = 0;
- Int_t hitDetector; // detector number (lay,lad,hitDetector)
- Int_t iWing; // which detector wing/side.
- Int_t detector; // 2*(detector-1)+iWing
- Int_t ii,kk,ka,kt; // loop indexs
- Int_t ia,it,index; // sub-pixel integration indexies
- Int_t iAnode; // anode number.
- Int_t timeSample; // time buckett.
- Int_t anodeWindow; // anode direction charge integration width
- Int_t timeWindow; // time direction charge integration width
- Int_t jamin,jamax; // anode charge integration window
- Int_t jtmin,jtmax; // time charge integration window
- Int_t ndiv; // Anode window division factor.
- Int_t nsplit; // the number of splits in anode and time windows==1.
- Int_t nOfSplits; // number of times track length is split into
- Float_t nOfSplitsF; // Floating point version of nOfSplits.
- Float_t kkF; // Floating point version of loop index kk.
- Float_t pathInSDD; // Track length in SDD.
- Float_t drPath; // average position of track in detector. in microns
- Float_t drTime; // Drift time
- Float_t nmul; // drift time window multiplication factor.
- Float_t avDrft; // x position of path length segment in cm.
- Float_t avAnode; // Anode for path length segment in Anode number (float)
- Float_t xAnode; // Floating point anode number.
- Float_t driftPath; // avDrft in microns.
- Float_t width; // width of signal at anodes.
+ Int_t itrack = 0;
+ Int_t hitDetector; // detector number (lay,lad,hitDetector)
+ Int_t iWing; // which detector wing/side.
+ Int_t detector; // 2*(detector-1)+iWing
+ Int_t ii,kk,ka,kt; // loop indexs
+ Int_t ia,it,index; // sub-pixel integration indexies
+ Int_t iAnode; // anode number.
+ Int_t timeSample; // time buckett.
+ Int_t anodeWindow; // anode direction charge integration width
+ Int_t timeWindow; // time direction charge integration width
+ Int_t jamin,jamax; // anode charge integration window
+ Int_t jtmin,jtmax; // time charge integration window
+ Int_t ndiv; // Anode window division factor.
+ Int_t nsplit; // the number of splits in anode and time windows==1.
+ Int_t nOfSplits; // number of times track length is split into
+ Float_t nOfSplitsF; // Floating point version of nOfSplits.
+ Float_t kkF; // Floating point version of loop index kk.
+ Double_t pathInSDD; // Track length in SDD.
+ Double_t drPath; // average position of track in detector. in microns
+ Double_t drTime; // Drift time
+ Double_t nmul; // drift time window multiplication factor.
+ Double_t avDrft; // x position of path length segment in cm.
+ Double_t avAnode; // Anode for path length segment in Anode number (float)
+ Double_t xAnode; // Floating point anode number.
+ Double_t driftPath; // avDrft in microns.
+ Double_t width; // width of signal at anodes.
Double_t depEnergy; // Energy deposited in this GEANT step.
Double_t xL[3],dxL[3]; // local hit coordinates and diff.
- Double_t sigA; // sigma of signal at anode.
- Double_t sigT; // sigma in time/drift direction for track segment
- Double_t aStep,aConst; // sub-pixel size and offset anode
- Double_t tStep,tConst; // sub-pixel size and offset time
- Double_t amplitude; // signal amplitude for track segment in nanoAmpere
- Double_t chargeloss; // charge loss for track segment.
- Double_t anodeAmplitude; // signal amplitude in anode direction
- Double_t aExpo; // exponent of Gaussian anode direction
- Double_t timeAmplitude; // signal amplitude in time direction
- Double_t tExpo; // exponent of Gaussian time direction
+ Double_t sigA; // sigma of signal at anode.
+ Double_t sigT; // sigma in time/drift direction for track segment
+ Double_t aStep,aConst; // sub-pixel size and offset anode
+ Double_t tStep,tConst; // sub-pixel size and offset time
+ Double_t amplitude; // signal amplitude for track segment in nanoAmpere
+ Double_t chargeloss; // charge loss for track segment.
+ Double_t anodeAmplitude; // signal amplitude in anode direction
+ Double_t aExpo; // exponent of Gaussian anode direction
+ Double_t timeAmplitude; // signal amplitude in time direction
+ Double_t tExpo; // exponent of Gaussian time direction
// Double_t tof; // Time of flight in ns of this step.
for(ii=0; ii<nhits; ii++) {
sddWidth,xAnode*anodePitch);
iAnode = (Int_t) (1.+xAnode); // xAnode?
if(iAnode < 1 || iAnode > nofAnodes) {
- Warning("HitToAnalogDigits","Wrong iAnode: 1<%d>%d",
- iAnode,nofAnodes);
+ Warning("HitToAnalogDigits","Wrong iAnode: 1<%d>%d (xanode=%e)",
+ iAnode,nofAnodes, xAnode);
continue;
} // end if iAnode < 1 || iAnode > nofAnodes
//____________________________________________
void AliITSsimulationSDD::AddDigit( Int_t i, Int_t j, Int_t signal ) {
// Adds a Digit.
- Int_t size = AliITSdigitSPD::GetNTracks();
+ Int_t size = AliITSdigit::GetNTracks();
+
Int_t digits[3];
Int_t * tracks = new Int_t[size];
Int_t * hits = new Int_t[size];
char opt1[20], opt2[20];
AliITSCalibrationSDD* res = (AliITSCalibrationSDD*)GetCalibrationModel(mod);
-
res->GetParamOptions(opt1,opt2);
- char *read = strstr(opt1,"file");
- Double_t baseline, noise;
-
- if (read) {
- static Bool_t readfile=kTRUE;
- //read baseline and noise from file
- if (readfile) ReadBaseline();
- readfile=kFALSE;
- } else res->GetNoiseParam(noise,baseline);
+ Double_t baseline=0;
+ Double_t noise=0;
Float_t contrib=0;
Int_t i,k,kk;
if(!fDoFFT) {
for (i=0;i<fNofMaps;i++) {
if( !fAnodeFire[i] ) continue;
- if (read && i<fNofMaps) GetAnodeBaseline(i,baseline,noise);
+ baseline = res->GetBaseline(i);
+ noise = res->GetNoise(i);
+
for(k=0; k<fScaleSize*fMaxNofSamples; k++) {
fInZR[k] = fHitMap2->GetSignal(i,k);
if( bAddNoise ) {
newcont = fInZR[fScaleSize*k+kk];
if(newcont > maxcont) maxcont = newcont;
} // end for kk
- newcont = maxcont;
+ newcont = maxcont;
if (newcont >= maxadc) newcont = maxadc -1;
if(newcont >= baseline){
Warning("","newcont=%d>=baseline=%d",newcont,baseline);
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++) {
+ baseline = res->GetBaseline(i);
+ noise = res->GetNoise(i);
+ for(k=0; k<fScaleSize*fMaxNofSamples; k++) {
fInZR[k] = fHitMap2->GetSignal(i,k);
if( bAddNoise ) {
contrib = (baseline + noise*gRandom->Gaus());
//____________________________________________________________________
void AliITSsimulationSDD::ApplyDeadChannels(Int_t mod) {
// Set dead channel signal to zero
- AliITSCalibrationSDD * response = (AliITSCalibrationSDD *)GetCalibrationModel(mod);
+ AliITSCalibrationSDD * calibr = (AliITSCalibrationSDD *)GetCalibrationModel(mod);
AliITSsegmentationSDD* seg = (AliITSsegmentationSDD*)GetSegmentationModel(1);
// nothing to do
- if( response->IsDead() ||
- ( response->GetDeadChips() == 0 &&
- response->GetDeadChannels() == 0 ) ) return;
+ if( calibr->IsDead() ||
+ ( calibr->GetDeadChips() == 0 &&
+ calibr->GetDeadChannels() == 0 ) ) return;
// static AliITS *iTS = (AliITS*)gAlice->GetModule( "ITS" );
// loop over wings
for( Int_t j=0; j<2; j++ ) {
// Int_t mod = (fModule-firstSDDMod)*2 + j;
- for( Int_t u=0; u<response->Chips(); u++ )
- for( Int_t v=0; v<response->Channels(); v++ ) {
- Float_t gain = response->Gain(j, u, v );
+ for( Int_t u=0; u<calibr->Chips(); u++ )
+ for( Int_t v=0; v<calibr->Channels(); v++ ) {
+ Float_t gain = calibr->Gain(j, u, v );
for( Int_t k=0; k<fMaxNofSamples; k++ ) {
- Int_t i = j*response->Chips()*response->Channels() +
- u*response->Channels() +
+ Int_t i = j*calibr->Chips()*calibr->Channels() +
+ u*calibr->Channels() +
v;
Double_t signal = gain * fHitMap2->GetSignal( i, k );
fHitMap2->SetHit( i, k, signal ); ///
return;
}
memset( ctk, 0, sizeof(Float_t)*(fNofMaps*fMaxNofSamples+1) );
- AliITSCalibrationSDD* res = (AliITSCalibrationSDD*)GetCalibrationModel(mod);
-
- Double_t noise, baseline;
- res->GetNoiseParam( noise, baseline );
+ AliITSCalibrationSDD* calibr = (AliITSCalibrationSDD*)GetCalibrationModel(mod);
for( Int_t z=0; z<fNofMaps; z++ ) {
+ Double_t baseline = calibr->GetBaseline(z);
Bool_t on = kFALSE;
Int_t tstart = 0;
Int_t tstop = 0;
delete [] ctk;
}
-//______________________________________________________________________
-void AliITSsimulationSDD::GetAnodeBaseline(Int_t i,Double_t &baseline,
- Double_t &noise) const{
- // Returns the Baseline for a particular anode.
- baseline = fBaseline[i];
- noise = fNoise[i];
-}
+
//______________________________________________________________________
void AliITSsimulationSDD::CompressionParam(Int_t i,Int_t &db,Int_t &tl,
- Int_t &th){
+ Int_t &th) const{
// Returns the compression alogirthm parameters
- Int_t size = fD.GetSize();
- if (size > 2 ) {
- db=fD[i]; tl=fT1[i]; th=fT2[i];
- } else {
- if (size <= 2 && i>=fNofMaps/2) {
- db=fD[1]; tl=fT1[1]; th=fT2[1];
- } else {
- db=fD[0]; tl=fT1[0]; th=fT2[0];
- } // end if size <=2 && i>=fNofMaps/2
- } // end if size >2
+ db=fD[i];
+ tl=fT1[i];
+ th=fT2[i];
}
//______________________________________________________________________
-void AliITSsimulationSDD::CompressionParam(Int_t i,Int_t &db,Int_t &tl){
+void AliITSsimulationSDD::CompressionParam(Int_t i,Int_t &db,Int_t &tl) const{
// returns the compression alogirthm parameters
- Int_t size = fD.GetSize();
- if (size > 2 ) {
- db=fD[i]; tl=fT1[i];
- } else {
- if (size <= 2 && i>=fNofMaps/2) {
- db=fD[1]; tl=fT1[1];
- } else {
- db=fD[0]; tl=fT1[0];
- } // end if size <=2 && i>=fNofMaps/2
- // Warning("CompressionParam",
- // "Size= %d . Values i=%d ; db= %d ; tl= %d",
- // size,i,db,tl);
- } // end if size > 2
+ db=fD[i];
+ tl=fT1[i];
+
}
//______________________________________________________________________
-void AliITSsimulationSDD::SetCompressParam(){
+void AliITSsimulationSDD::SetCompressParam(){
// Sets the compression alogirthm parameters
- Int_t cp[8],i;
- AliITSCalibrationSDD* res = (AliITSCalibrationSDD*)GetCalibrationModel(fDetType->GetITSgeom()->GetStartSDD());
-
- res->GiveCompressParam(cp);
- for (i=0; i<2; i++) {
- fD[i] = cp[i];
- fT1[i] = cp[i+2];
- fT2[i] = cp[i+4];
- fTol[i] = cp[i+6];
- } // end for i
-}
-//______________________________________________________________________
-void AliITSsimulationSDD::ReadBaseline(){
- // read baseline and noise from file - either a .root file and in this
- // case data should be organised in a tree with one entry for each
- // module => reading should be done accordingly
- // or a classic file and do smth. like this:
- // Read baselines and noise for SDD
-
- Int_t na,pos;
- Float_t bl,n;
- char input[100], base[100], param[100];
- char *filtmp;
- AliITSCalibrationSDD* res = (AliITSCalibrationSDD*)GetCalibrationModel(fDetType->GetITSgeom()->GetStartSDD());
- res->Filenames(input,base,param);
- fFileName=base;
- //
- filtmp = gSystem->ExpandPathName(fFileName.Data());
- FILE *bline = fopen(filtmp,"r");
- na = 0;
-
- if(bline) {
- while(fscanf(bline,"%d %f %f",&pos, &bl, &n) != EOF) {
- if (pos != na+1) {
- Error("ReadBaseline","Anode number not in increasing order!",
- filtmp);
- exit(1);
- } // end if pos != na+1
- fBaseline[na]=bl;
- fNoise[na]=n;
- na++;
- } // end while
- } else {
- Error("ReadBaseline"," THE BASELINE FILE %s DOES NOT EXIST !",filtmp);
- exit(1);
- } // end if(bline)
-
- fclose(bline);
- delete [] filtmp;
+ AliITSCalibrationSDD* calibr = (AliITSCalibrationSDD*)GetCalibrationModel(fModule);
+ for(Int_t ian = 0; ian<fNofMaps;ian++){
+ fD[ian] = (Int_t)(calibr->GetBaseline(ian));
+ fT1[ian] = (Int_t)(2.*calibr->GetNoiseAfterElectronics(ian)+0.5);
+ fT2[ian] = 0; // used by 2D clustering - not defined yet
+ fTol[ian] = 0; // used by 2D clustering - not defined yet
+ }
}
//______________________________________________________________________
Int_t AliITSsimulationSDD::Convert10to8(Int_t signal) const {
//______________________________________________________________________
void AliITSsimulationSDD::ZeroSuppression(const char *option) {
// perform the zero suppresion
-
if (strstr(option,"2D")) {
//Init2D(); // activate if param change module by module
Compress2D();
char input[100],basel[100],par[100];
char *filtmp;
Double_t tmp1,tmp2;
- AliITSCalibrationSDD* res = (AliITSCalibrationSDD*)GetCalibrationModel(fDetType->GetITSgeom()->GetStartSDD());
+ AliITSCalibrationSDD* res = (AliITSCalibrationSDD*)GetCalibrationModel(fModule);
res->Thresholds(tmp1,tmp2);
Int_t minval = static_cast<Int_t>(tmp1);
Int_t db,tl,th;
Double_t tmp1,tmp2;
- AliITSCalibrationSDD* res = (AliITSCalibrationSDD*)GetCalibrationModel(fDetType->GetITSgeom()->GetStartSDD());
+ AliITSCalibrationSDD* res = (AliITSCalibrationSDD*)GetCalibrationModel(fModule);
res->Thresholds(tmp1,tmp2);
Int_t minval = static_cast<Int_t>(tmp1);
Bool_t write = res->OutputOption();
Bool_t do10to8 = res->Do10to8();
Int_t nz, nl, nh, low, i, j;
-
+ SetCompressParam();
for (i=0; i<fNofMaps; i++) {
CompressionParam(i,db,tl,th);
nz = 0;
void AliITSsimulationSDD::FindCluster(Int_t i,Int_t j,Int_t signal,
Int_t minval,Bool_t &cond){
// Find clusters according to the online 2D zero-suppression algorithm
- AliITSCalibrationSDD* res = (AliITSCalibrationSDD*)GetCalibrationModel(fDetType->GetITSgeom()->GetStartSDD());
+ AliITSCalibrationSDD* res = (AliITSCalibrationSDD*)GetCalibrationModel(fModule);
AliITSsegmentationSDD* seg = (AliITSsegmentationSDD*)GetSegmentationModel(1);
Bool_t do10to8 = res->Do10to8();
char input[100],basel[100],par[100];
char *filtmp;
Double_t tmp1,tmp2;
- AliITSCalibrationSDD* res = (AliITSCalibrationSDD*)GetCalibrationModel(fDetType->GetITSgeom()->GetStartSDD());
+ AliITSCalibrationSDD* res = (AliITSCalibrationSDD*)GetCalibrationModel(fModule);
res->Thresholds(tmp1,tmp2);
Int_t minval = static_cast<Int_t>(tmp1);
Int_t dis,tol,thres,decr,diff;
UChar_t *str=fStream->Stream();
Int_t counter=0;
- AliITSCalibrationSDD* res = (AliITSCalibrationSDD*)GetCalibrationModel(fDetType->GetITSgeom()->GetStartSDD());
+ AliITSCalibrationSDD* res = (AliITSCalibrationSDD*)GetCalibrationModel(fModule);
Bool_t do10to8=res->Do10to8();
Int_t last=0;
Int_t k,i,j;
-
+ SetCompressParam();
for (k=0; k<2; k++) {
tol = Tolerance(k);
dis = Disable(k);
//______________________________________________________________________
void AliITSsimulationSDD::StoreAllDigits(){
// if non-zero-suppressed data
- AliITSCalibrationSDD* res = (AliITSCalibrationSDD*)GetCalibrationModel(fDetType->GetITSgeom()->GetStartSDD());
+ AliITSCalibrationSDD* res = (AliITSCalibrationSDD*)GetCalibrationModel(fModule);
Bool_t do10to8 = res->Do10to8();
Int_t i, j, digits[3];
digits[1] = j;
digits[2] = signal;
fITS->AddRealDigit(1,digits);
- } // end for j
+ } // end for j
} // end for i
}
//______________________________________________________________________
Int_t decr;
Int_t threshold = fT1[0];
char opt1[20], opt2[20];
- AliITSCalibrationSDD* res = (AliITSCalibrationSDD*)GetCalibrationModel(fDetType->GetITSgeom()->GetStartSDD());
-
+ AliITSCalibrationSDD* res = (AliITSCalibrationSDD*)GetCalibrationModel(fModule);
+ SetCompressParam();
res->GetParamOptions(opt1,opt2);
fParam=opt2;
- char *same = strstr(opt1,"same");
Double_t noise,baseline;
- if (same) {
- res->GetNoiseParam(noise,baseline);
- } else {
- static Bool_t readfile=kTRUE;
- //read baseline and noise from file
- if (readfile) ReadBaseline();
- readfile=kFALSE;
- } // end if same
+ //GetBaseline(fModule);
TCanvas *c2 = (TCanvas*)gROOT->GetListOfCanvases()->FindObject("c2");
if(c2) delete c2->GetPrimitive("noisehist");
Int_t i,k;
for (i=0;i<fNofMaps;i++) {
CompressionParam(i,decr,threshold);
- if (!same) GetAnodeBaseline(i,baseline,noise);
+ baseline = res->GetBaseline(i);
+ noise = res->GetNoise(i);
anode->Reset();
for (k=0;k<fMaxNofSamples;k++) {
Float_t signal=(Float_t)fHitMap2->GetSignal(i,k);
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff