#include <stdio.h>
#include <string.h>
-#include <TSystem.h>
-#include <TROOT.h>
-#include <TStopwatch.h>
#include <TCanvas.h>
#include <TF1.h>
-#include <TRandom.h>
#include <TH1.h>
#include <TFile.h>
-#include <TVector.h>
-#include <TArrayI.h>
-#include <TArrayF.h>
-#include "AliRun.h"
#include "AliITS.h"
-#include "AliITShit.h"
-#include "AliITSdigitSDD.h"
+#include "AliITSMapA2.h"
+#include "AliITSRawData.h"
#include "AliITSdigitSPD.h"
+#include "AliITSetfSDD.h"
#include "AliITSmodule.h"
#include "AliITSpList.h"
-#include "AliITSMapA1.h"
-#include "AliITSMapA2.h"
-#include "AliITSetfSDD.h"
-#include "AliITSRawData.h"
-#include "AliITSHuffman.h"
-#include "AliITSgeom.h"
-#include "AliITSsegmentation.h"
-#include "AliITSresponse.h"
-#include "AliITSsegmentationSDD.h"
#include "AliITSresponseSDD.h"
+#include "AliITSCalibrationSDD.h"
+#include "AliITSsegmentationSDD.h"
#include "AliITSsimulationSDD.h"
+#include "AliLog.h"
+#include "AliRun.h"
ClassImp(AliITSsimulationSDD)
////////////////////////////////////////////////////////////////////////
-// Version: 0
-// Written by Piergiorgio Cerello
-// November 23 1999
-//
-// AliITSsimulationSDD is the simulation of SDDs.
- //
-//Begin_Html
-/*
- <img src="picts/ITS/AliITShit_Class_Diagram.gif">
- </pre>
- <br clear=left>
- <font size=+2 color=red>
- <p>This show the relasionships between the ITS hit class and the
- rest of Aliroot.
- </font>
- <pre>
-*/
-//End_Html
- //______________________________________________________________________
+// Version: 0 //
+// Written by Piergiorgio Cerello //
+// November 23 1999 //
+// //
+// AliITSsimulationSDD is the simulation of SDDs. //
+////////////////////////////////////////////////////////////////////////
+
+//______________________________________________________________________
Int_t power(Int_t b, Int_t e) {
// compute b to the e power, where both b and e are Int_ts.
Int_t power = 1,i;
fD(),
fT1(),
fTol(),
-fBaseline(),
-fNoise(),
fTreeB(0),
fFileName(),
fFlag(kFALSE),
// Copy constructor to satify Coding roules only.
if(this==&source) return;
- Error("AliITSsimulationSSD","Not allowed to make a copy of "
+ Error("AliITSsimulationSDD","Not allowed to make a copy of "
"AliITSsimulationSDD Using default creater instead");
AliITSsimulationSDD();
}
//______________________________________________________________________
-AliITSsimulationSDD& AliITSsimulationSDD::operator=(AliITSsimulationSDD &src){
+AliITSsimulationSDD& AliITSsimulationSDD::operator=(const AliITSsimulationSDD &src){
+ // Assignment operator to satify Coding roules only.
+
+ if(this==&src) return *this;
+ Error("AliITSsimulationSDD","Not allowed to make a = with "
+ "AliITSsimulationSDD Using default creater instead");
+ return *this ;
+}
+//______________________________________________________________________
+AliITSsimulation& AliITSsimulationSDD::operator=(const AliITSsimulation &src){
// Assignment operator to satify Coding roules only.
if(this==&src) return *this;
"AliITSsimulationSDD Using default creater instead");
return *this ;
}
+
//______________________________________________________________________
-AliITSsimulationSDD::AliITSsimulationSDD(AliITSsegmentation *seg,
- AliITSresponse *resp):
-AliITSsimulation(seg,resp),
+AliITSsimulationSDD::AliITSsimulationSDD(AliITSDetTypeSim* dettyp):
+AliITSsimulation(dettyp),
fITS(0),
fHitMap2(0),
fHitSigMap2(0),
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(){
SetDoFFT();
SetCheckNoise();
- fpList = new AliITSpList( GetSeg()->Npz(),
- fScaleSize*GetSeg()->Npx() );
- fHitSigMap2 = new AliITSMapA2(GetSeg(),fScaleSize,1);
- fHitNoiMap2 = new AliITSMapA2(GetSeg(),fScaleSize,1);
+ AliITSsegmentationSDD* seg = (AliITSsegmentationSDD*)GetSegmentationModel(1);
+
+ AliITSresponseSDD* res = (AliITSresponseSDD*)fDetType->GetResponse(1);
+ fpList = new AliITSpList( seg->Npz(),
+ fScaleSize*seg->Npx() );
+ fHitSigMap2 = new AliITSMapA2(seg,fScaleSize,1);
+ fHitNoiMap2 = new AliITSMapA2(seg,fScaleSize,1);
fHitMap2 = fHitSigMap2;
- fNofMaps = GetSeg()->Npz();
- fMaxNofSamples = GetSeg()->Npx();
+ fNofMaps = seg->Npz();
+ fMaxNofSamples = seg->Npx();
fAnodeFire = new Bool_t [fNofMaps];
- Float_t sddLength = GetSeg()->Dx();
- Float_t sddWidth = GetSeg()->Dz();
+ Float_t sddLength = seg->Dx();
+ Float_t sddWidth = seg->Dz();
Int_t dummy = 0;
- Float_t anodePitch = GetSeg()->Dpz(dummy);
- Double_t timeStep = (Double_t)GetSeg()->Dpx(dummy);
- Float_t driftSpeed = GetResp()->DriftSpeed();
+ Float_t anodePitch = seg->Dpz(dummy);
+ Double_t timeStep = (Double_t)seg->Dpx(dummy);
+ Float_t driftSpeed = res->DriftSpeed();
if(anodePitch*(fNofMaps/2) > sddWidth) {
Warning("AliITSsimulationSDD",
} // end if
fElectronics = new AliITSetfSDD(timeStep/fScaleSize,
- GetResp()->Electronics());
+ res->Electronics());
char opt1[20], opt2[20];
- GetResp()->ParamOptions(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=GetResp()->ZeroSuppOption();
- 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
-
- Bool_t write = GetResp()->OutputOption();
+ 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);
InitSimulationModule( md, ev );
HitsToAnalogDigits( mod );
- ChargeToSignal( kFALSE ); // - Process signal without add noise
+ ChargeToSignal( fModule,kFALSE ); // - Process signal without add noise
fHitMap2 = fHitNoiMap2; // - Swap to noise map
- ChargeToSignal( kTRUE ); // - Process only noise
+ ChargeToSignal( fModule,kTRUE ); // - Process only noise
fHitMap2 = fHitSigMap2; // - Return to signal map
WriteSDigits();
ClearMaps();
Bool_t AliITSsimulationSDD::AddSDigitsToModule(TClonesArray *pItemArray,
Int_t mask ) {
// Add Summable digits to module maps.
+ AliITSresponseSDD* res = (AliITSresponseSDD*)fDetType->GetResponse(1);
Int_t nItems = pItemArray->GetEntries();
- Double_t maxadc = GetResp()->MaxAdc();
+ Double_t maxadc = res->MaxAdc();
Bool_t sig = kFALSE;
// cout << "Adding "<< nItems <<" SDigits to module " << fModule << endl;
InitSimulationModule( md, ev );
if( !nhits && fCheckNoise ) {
- ChargeToSignal( kTRUE ); // process noise
+ ChargeToSignal( fModule,kTRUE ); // process noise
GetNoise();
ClearMaps();
return;
if( !nhits ) return;
HitsToAnalogDigits( mod );
- ChargeToSignal( kTRUE ); // process signal + noise
+ ChargeToSignal( fModule,kTRUE ); // process signal + noise
for( Int_t i=0; i<fNofMaps; i++ ) {
for( Int_t j=0; j<fMaxNofSamples; j++ ) {
void AliITSsimulationSDD::FinishDigits() {
// introduce the electronics effects and do zero-suppression if required
- ApplyDeadChannels();
- if( fCrosstalkFlag ) ApplyCrosstalk();
+ ApplyDeadChannels(fModule);
+ if( fCrosstalkFlag ) ApplyCrosstalk(fModule);
- const char *kopt = GetResp()->ZeroSuppOption();
+ AliITSCalibrationSDD* res = (AliITSCalibrationSDD*)GetCalibrationModel(fModule);
+ const char *kopt = res->GetZeroSuppOption();
ZeroSuppression( kopt );
}
//______________________________________________________________________
void AliITSsimulationSDD::HitsToAnalogDigits( AliITSmodule *mod ) {
// create maps to build the lists of tracks for each digit
- TObjArray *hits = mod->GetHits();
+ AliITSsegmentationSDD* seg = (AliITSsegmentationSDD*)GetSegmentationModel(1);
+ 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 = GetSeg()->Dx();
- Float_t sddWidth = GetSeg()->Dz();
- Float_t anodePitch = GetSeg()->Dpz(dummy);
- Float_t timeStep = GetSeg()->Dpx(dummy);
- Float_t driftSpeed = GetResp()->DriftSpeed();
- Float_t maxadc = GetResp()->MaxAdc();
- Float_t topValue = GetResp()->DynamicRange();
- Float_t cHloss = GetResp()->ChargeLoss();
+ 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;
- Double_t dfCoeff, s1; GetResp()->DiffCoeff(dfCoeff,s1); // Signal 2d Shape
- Double_t eVpairs = 3.6; // electron pair energy eV.
- // GetResp()->GetGeVToCharge()/1.0E8; //2.778
- Float_t nsigma = GetResp()->NSigmaIntegration(); //
- Int_t nlookups = GetResp()->GausNLookUp(); //
- Float_t jitter = ((AliITSresponseSDD*)GetResp())->JitterError(); //
+ 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(); //
// Piergiorgio's part (apart for few variables which I made float
// when i thought that can be done
// continue if the particle did not lose energy
// passing through detector
if (!depEnergy) {
- if(GetDebug()){
- Warning("HitsToAnalogDigits",
- "fTrack = %d hit=%d module=%d This particle has"
- " passed without losing energy!",
- itrack,ii,mod->GetIndex());
- }
+ AliDebug(1,
+ Form("fTrack = %d hit=%d module=%d This particle has passed without losing energy!",
+ itrack,ii,mod->GetIndex()));
continue;
} // end if !depEnergy
if(drPath < 0) drPath = -drPath;
drPath = sddLength-drPath;
if(drPath < 0) {
- if(GetDebug()){ // this should be fixed at geometry level
- Warning("HitsToAnalogDigits",
- "negative drift path drPath=%e sddLength=%e dxL[0]=%e "
- "xL[0]=%e",
- drPath,sddLength,dxL[0],xL[0]);
- }
+ AliDebug(1, // this should be fixed at geometry level
+ Form("negative drift path drPath=%e sddLength=%e dxL[0]=%e xL[0]=%e",
+ drPath,sddLength,dxL[0],xL[0]));
continue;
} // end if drPath < 0
driftPath = sddLength-driftPath;
detector = 2*(hitDetector-1) + iWing;
if(driftPath < 0) {
- if(GetDebug()){ // this should be fixed at geometry level
- Warning("HitsToAnalogDigits","negative drift path "
- "driftPath=%e sddLength=%e avDrft=%e dxL[0]=%e "
- "xL[0]=%e",driftPath,sddLength,avDrft,dxL[0],
- xL[0]);
- }
+ AliDebug(1, // this should be fixed at geometry level
+ Form("negative drift path driftPath=%e sddLength=%e avDrft=%e dxL[0]=%e xL[0]=%e",
+ driftPath,sddLength,avDrft,dxL[0],xL[0]));
continue;
} // end if driftPath < 0
if(TMath::Abs(aExpo) > nsigma) anodeAmplitude = 0.;
else {
dummy = (Int_t) ((aExpo+nsigma)/width);
- anodeAmplitude = amplitude*GetResp()->GausLookUp(dummy);
+ anodeAmplitude = amplitude*res->GetGausLookUp(dummy);
} // end if TMath::Abs(aEspo) > nsigma
// index starts from 0
index = ((detector+1)%2)*nofAnodes+ia-1;
else {
dummy = (Int_t) ((tExpo+nsigma)/width);
timeAmplitude = anodeAmplitude*
- GetResp()->GausLookUp(dummy);
+ res->GetGausLookUp(dummy);
} // end if TMath::Abs(tExpo) > nsigma
// build the list of Sdigits for this module
// arg[0] = index;
trlist->Add(&trinfo);
} // end if lasttrack==idtrack
- if(GetDebug()){
+ if(AliDebugLevel()){
// check the track list - debugging
Int_t trk[20], htrk[20];
Float_t chtrk[20];
cout << "nptracks "<<nptracks << endl;
} // end for tr
} // end if nptracks
- } // end if GetDebug()
+ } // end if AliDebugLevel()
} // end if pdigit
// update counter and countadr for next call.
delete [] charges;
}
//______________________________________________________________________
-void AliITSsimulationSDD::ChargeToSignal(Bool_t bAddNoise) {
+void AliITSsimulationSDD::ChargeToSignal(Int_t mod,Bool_t bAddNoise) {
// add baseline, noise, electronics and ADC saturation effects
char opt1[20], opt2[20];
- GetResp()->ParamOptions(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 GetResp()->GetNoiseParam(noise,baseline);
+ AliITSCalibrationSDD* res = (AliITSCalibrationSDD*)GetCalibrationModel(mod);
+ res->GetParamOptions(opt1,opt2);
+ Double_t baseline=0;
+ Double_t noise=0;
Float_t contrib=0;
Int_t i,k,kk;
- Float_t maxadc = GetResp()->MaxAdc();
+ Float_t maxadc = res->GetMaxAdc();
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());
return;
}
//____________________________________________________________________
-void AliITSsimulationSDD::ApplyDeadChannels() {
+void AliITSsimulationSDD::ApplyDeadChannels(Int_t mod) {
// Set dead channel signal to zero
- AliITSresponseSDD * response = (AliITSresponseSDD *)GetResp();
-
+ AliITSCalibrationSDD * calibr = (AliITSCalibrationSDD *)GetCalibrationModel(mod);
+ AliITSsegmentationSDD* seg = (AliITSsegmentationSDD*)GetSegmentationModel(1);
// nothing to do
- if( response->GetDeadModules() == 0 &&
- response->GetDeadChips() == 0 &&
- response->GetDeadChannels() == 0 )
- return;
+ if( calibr->IsDead() ||
+ ( calibr->GetDeadChips() == 0 &&
+ calibr->GetDeadChannels() == 0 ) ) return;
- static AliITS *iTS = (AliITS*)gAlice->GetModule( "ITS" );
+ // static AliITS *iTS = (AliITS*)gAlice->GetModule( "ITS" );
- Int_t fMaxNofSamples = GetSeg()->Npx();
- AliITSgeom *geom = iTS->GetITSgeom();
- Int_t firstSDDMod = geom->GetStartDet( 1 );
+ Int_t fMaxNofSamples = seg->Npx();
+ // AliITSgeom *geom = iTS->GetITSgeom();
+ // Int_t firstSDDMod = geom->GetStartDet( 1 );
// 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( mod, u, v );
- for( Int_t k=0; k<fMaxNofSamples; k++ ) {
- Int_t i = j*response->Chips()*response->Channels() +
- u*response->Channels() +
- v;
- Double_t signal = Gain * fHitMap2->GetSignal( i, k );
- fHitMap2->SetHit( i, k, signal ); ///
- }
- }
- }
+ // Int_t mod = (fModule-firstSDDMod)*2 + j;
+ 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*calibr->Chips()*calibr->Channels() +
+ u*calibr->Channels() +
+ v;
+ Double_t signal = gain * fHitMap2->GetSignal( i, k );
+ fHitMap2->SetHit( i, k, signal ); ///
+ }
+ }
+ }
}
//______________________________________________________________________
-void AliITSsimulationSDD::ApplyCrosstalk() {
+void AliITSsimulationSDD::ApplyCrosstalk(Int_t mod) {
// function add the crosstalk effect to signal
// temporal function, should be checked...!!!
-
- Int_t fNofMaps = GetSeg()->Npz();
- Int_t fMaxNofSamples = GetSeg()->Npx();
+ AliITSsegmentationSDD* seg = (AliITSsegmentationSDD*)GetSegmentationModel(1);
+
+ Int_t fNofMaps = seg->Npz();
+ Int_t fMaxNofSamples = seg->Npx();
// create and inizialice crosstalk map
Float_t* ctk = new Float_t[fNofMaps*fMaxNofSamples+1];
return;
}
memset( ctk, 0, sizeof(Float_t)*(fNofMaps*fMaxNofSamples+1) );
-
- Double_t noise, baseline;
- GetResp()->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){
- // 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;
-
- GetResp()->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;
-
- GetResp()->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 {
char input[100],basel[100],par[100];
char *filtmp;
Double_t tmp1,tmp2;
- GetResp()->Thresholds(tmp1,tmp2);
+ AliITSCalibrationSDD* res = (AliITSCalibrationSDD*)GetCalibrationModel(fModule);
+
+ res->Thresholds(tmp1,tmp2);
Int_t minval = static_cast<Int_t>(tmp1);
- GetResp()->Filenames(input,basel,par);
+ res->Filenames(input,basel,par);
fFileName = par;
//
filtmp = gSystem->ExpandPathName(fFileName.Data());
Int_t db,tl,th;
Double_t tmp1,tmp2;
- GetResp()->Thresholds(tmp1,tmp2);
+ AliITSCalibrationSDD* res = (AliITSCalibrationSDD*)GetCalibrationModel(fModule);
+
+ res->Thresholds(tmp1,tmp2);
Int_t minval = static_cast<Int_t>(tmp1);
- Bool_t write = GetResp()->OutputOption();
- Bool_t do10to8 = GetResp()->Do10to8();
+ 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
- Bool_t do10to8 = GetResp()->Do10to8();
+ AliITSCalibrationSDD* res = (AliITSCalibrationSDD*)GetCalibrationModel(fModule);
+ AliITSsegmentationSDD* seg = (AliITSsegmentationSDD*)GetSegmentationModel(1);
+
+ Bool_t do10to8 = res->Do10to8();
Bool_t high = kFALSE;
fHitMap2->FlagHit(i,j);
Int_t nn;
Int_t dbx,tlx,thx;
Int_t xList[kMaxNeighbours], yList[kMaxNeighbours];
- GetSeg()->Neighbours(i,j,&nn,xList,yList);
+ seg->Neighbours(i,j,&nn,xList,yList);
Int_t in,ix,iy,qns;
for (in=0; in<nn; in++) {
ix=xList[in];
char input[100],basel[100],par[100];
char *filtmp;
Double_t tmp1,tmp2;
- GetResp()->Thresholds(tmp1,tmp2);
+ AliITSCalibrationSDD* res = (AliITSCalibrationSDD*)GetCalibrationModel(fModule);
+
+ res->Thresholds(tmp1,tmp2);
Int_t minval = static_cast<Int_t>(tmp1);
- GetResp()->Filenames(input,basel,par);
+ res->Filenames(input,basel,par);
fFileName=par;
// set first the disable and tol param
Int_t dis,tol,thres,decr,diff;
UChar_t *str=fStream->Stream();
Int_t counter=0;
- Bool_t do10to8=GetResp()->Do10to8();
+ 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);
// open file and write out the stream of diff's
static Bool_t open=kTRUE;
static TFile *outFile;
- Bool_t write = GetResp()->OutputOption();
+ Bool_t write = res->OutputOption();
TDirectory *savedir = gDirectory;
if (write ) {
//______________________________________________________________________
void AliITSsimulationSDD::StoreAllDigits(){
// if non-zero-suppressed data
- Bool_t do10to8 = GetResp()->Do10to8();
+ AliITSCalibrationSDD* res = (AliITSCalibrationSDD*)GetCalibrationModel(fModule);
+
+ Bool_t do10to8 = res->Do10to8();
Int_t i, j, digits[3];
for (i=0; i<fNofMaps; i++) {
Int_t decr;
Int_t threshold = fT1[0];
char opt1[20], opt2[20];
-
- GetResp()->ParamOptions(opt1,opt2);
+ AliITSCalibrationSDD* res = (AliITSCalibrationSDD*)GetCalibrationModel(fModule);
+ SetCompressParam();
+ res->GetParamOptions(opt1,opt2);
fParam=opt2;
- char *same = strstr(opt1,"same");
Double_t noise,baseline;
- if (same) {
- GetResp()->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);
return;
}
//______________________________________________________________________
-void AliITSsimulationSDD::Print() {
+void AliITSsimulationSDD::PrintStatus() const {
// Print SDD simulation Parameters
cout << "**************************************************" << endl;
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff