// set the signal threshold for cluster finder
Double_t baseline,noiseAfterEl;
-
+ AliITSresponseSDD* res = (AliITSresponseSDD*)((AliITSCalibrationSDD*)GetResp(mod))->GetResponse();
+ const char *option=res->ZeroSuppOption();
Int_t nanodes = GetResp(mod)->Wings()*GetResp(mod)->Channels()*GetResp(mod)->Chips();
fCutAmplitude.Set(nanodes);
for(Int_t ian=0;ian<nanodes;ian++){
- baseline=GetResp(mod)->GetBaseline(ian);
noiseAfterEl = ((AliITSCalibrationSDD*)GetResp(mod))->GetNoiseAfterElectronics(ian);
- fCutAmplitude[ian] = (Int_t)((baseline + nsigma*noiseAfterEl));
+ if((strstr(option,"1D")) || (strstr(option,"2D"))){
+ fCutAmplitude[ian] = (Int_t)(nsigma*noiseAfterEl);
+ }
+ else{
+ baseline=GetResp(mod)->GetBaseline(ian);
+ fCutAmplitude[ian] = (Int_t)((baseline + nsigma*noiseAfterEl));
+ }
}
}
//______________________________________________________________________
Double_t fSddLength = GetSeg()->Dx();
Double_t anodePitch = GetSeg()->Dpz(dummy);
AliITSCalibrationSDD* cal = (AliITSCalibrationSDD*)GetResp(fModule);
+ AliITSresponseSDD* res = (AliITSresponseSDD*)((AliITSCalibrationSDD*)GetResp(fModule))->GetResponse();
+ const char *option=res->ZeroSuppOption();
+
// map the signal
Map()->ClearMap();
Map()->SetThresholdArr(fCutAmplitude);
Int_t clusterMult = 0;
Double_t clusterPeakAmplitude = 0.;
Int_t its,peakpos = -1;
- //Double_t n, baseline;
- //GetResp(fModule)->GetNoiseParam(n,baseline);
- Double_t baseline=GetResp(fModule)->GetBaseline(idx);
+
for(its=tstart; its<=tstop; its++) {
fadc=(float)Map()->GetSignal(idx,its);
- if(fadc>baseline) fadc -= baseline;
- else fadc = 0.;
+ if(!((strstr(option,"1D")) || (strstr(option,"2D")))){
+ Double_t baseline=GetResp(fModule)->GetBaseline(idx);
+ if(fadc>baseline) fadc -= baseline;
+ else fadc = 0.;
+ }
clusterCharge += fadc;
// as a matter of fact we should take the peak
// pos before FFT
Map()->SetThresholdArr( fCutAmplitude );
Map()->FillMap2();
+ AliITSresponseSDD* res = (AliITSresponseSDD*)cal->GetResponse();
+ const char *option=res->ZeroSuppOption();
+
Int_t nClu = 0;
// cout << "Search cluster... "<< endl;
for( Int_t j=0; j<2; j++ ){
for( Int_t k=0; k<fNofAnodes; k++ ){
- Int_t idx = j*fNofAnodes+k;
- Double_t baseline=GetResp(fModule)->GetBaseline(idx);
+ Int_t idx = j*fNofAnodes+k;
Bool_t on = kFALSE;
Int_t start = 0;
Int_t nTsteps = 0;
nTsteps = 0;
} // end if on...
nTsteps++ ;
- if( fadc > baseline ) fadc -= baseline;
- else fadc=0.;
+ if(!((strstr(option,"1D")) || (strstr(option,"2D")))){
+ Double_t baseline=GetResp(fModule)->GetBaseline(idx);
+ if( fadc > baseline ) fadc -= baseline;
+ else fadc=0.;
+ }
charge += fadc;
time += fadc*l;
if( fadc > fmax ){
Double_t fTimeStep = GetSeg()->Dpx( dummy );
Double_t fSddLength = GetSeg()->Dx();
Double_t anodePitch = GetSeg()->Dpz( dummy );
- //Double_t n, baseline;
- //GetResp(fModule)->GetNoiseParam( n, baseline );
Int_t electronics =GetResp(fModule)->GetElectronics(); // 1 = PASCAL, 2 = OLA
AliITSCalibrationSDD* cal = (AliITSCalibrationSDD*)GetResp(fModule);
+ AliITSresponseSDD* res = (AliITSresponseSDD*)cal->GetResponse();
+ const char *option=res->ZeroSuppOption();
for( Int_t j=0; j<nofClusters; j++ ){
// make a local map from cluster region
for( Int_t ianode=astart; ianode<=astop; ianode++ ){
for( Int_t itime=tstart; itime<=tstop; itime++ ){
- Double_t fadc = Map()->GetSignal( ianode, itime );
- Double_t baseline=GetResp(fModule)->GetBaseline(ianode);
- if( fadc > baseline ) fadc -= (Double_t)baseline;
- else fadc = 0.;
+ Double_t fadc = Map()->GetSignal( ianode, itime );
+ if(!((strstr(option,"1D")) || (strstr(option,"2D")))){
+ Double_t baseline=GetResp(fModule)->GetBaseline(ianode);
+ if( fadc > baseline ) fadc -= (Double_t)baseline;
+ else fadc = 0.;
+ }
Int_t index = (itime-tstart+1)*zdim+(ianode-astart+1);
sp[index] = fadc;
} // time loop
#include "AliITSRecPoint.h"
#include "AliITSDetTypeRec.h"
#include "AliRawReader.h"
-#include "AliITSRawStreamSDDv3.h"
+#include "AliITSRawStreamSDD.h"
#include "AliITSCalibrationSDD.h"
#include "AliITSDetTypeRec.h"
#include "AliITSsegmentationSDD.h"
bins[0]=new AliBin[kMAXBIN];
bins[1]=new AliBin[kMAXBIN];
AliITSCalibrationSDD* cal = (AliITSCalibrationSDD*)GetResp(fModule);
-
+ AliITSresponseSDD* res = (AliITSresponseSDD*)cal->GetResponse();
+ const char *option=res->ZeroSuppOption();
AliITSdigitSDD *d=0;
Int_t i, ndigits=digits->GetEntriesFast();
for (i=0; i<ndigits; i++) {
d=(AliITSdigitSDD*)digits->UncheckedAt(i);
- Float_t baseline = cal->GetBaseline(d->GetCoord1());
-
Int_t y=d->GetCoord2()+1; //y
Int_t z=d->GetCoord1()+1; //z
Int_t q=d->GetSignal();
-
- if(q>baseline) q-=(Int_t)baseline;
- else q=0;
+ if(!((strstr(option,"1D")) || (strstr(option,"2D")))){
+ Float_t baseline = cal->GetBaseline(d->GetCoord1());
+ if(q>baseline) q-=(Int_t)baseline;
+ else q=0;
+ }
if(q<cal->GetThresholdAnode(d->GetCoord1())) continue;
-
+
//if (q<3) continue;
if (z <= fNzSDD) {
Float_t hit[5] = {y, z, 0.0030*0.0030, 0.0020*0.0020, q};
Int_t info[3] = {maxj-minj+1, maxi-mini+1, fNlayer[fModule]};
- //if (c.GetQ() < 20.) continue; //noise cluster
+ if (c.GetQ() < 20.) continue; //noise cluster
if (digits) {
// AliBin *b=&bins[s][idx[k]];
// This function creates ITS clusters from raw data
//------------------------------------------------------------
rawReader->Reset();
- AliITSRawStreamSDDv3 inputSDD(rawReader);
+ AliITSRawStreamSDD inputSDD(rawReader);
FindClustersSDD(&inputSDD,clusters);
}
void SetCoarseDiffPhiCut(Float_t dphi = 0.5){fCoarseDiffPhiCut=dphi;}
void SetCoarseMaxRCut(Float_t rad = 2.5){fCoarseMaxRCut=rad;}
void SetMaxRCut(Float_t rad = 0.5){fMaxRCut=rad;}
- void SetZCutDiamond(Float_t zcut = 5.3){fZCutDiamond=zcut;}
+ void SetZCutDiamond(Float_t zcut = 14.0){fZCutDiamond=zcut;}
void SetMaxZCut(Float_t dz = 0.5){fMaxZCut=dz;}
void SetDCAcut(Float_t dca=0.1){fDCAcut=dca;}
void SetDiffPhiMax(Float_t pm = 0.01){fDiffPhiMax = pm;}
fCoord2(0),
fSignal(0){
//default constructor. zero all values.
+ for(Int_t i=0;i<fgkSize;i++) fTracks[i] = 0;
+ for(Int_t i=0;i<fgkSize;i++) fHits[i] = 0;
+
}
fCoord2(digits[1]),
fSignal(digits[2]){
// Creates a real data digit object
+ for(Int_t i=0;i<fgkSize;i++) fTracks[i] = 0;
+ for(Int_t i=0;i<fgkSize;i++) fHits[i] = 0;
+
}
//______________________________________________________________________
//Destructor
virtual ~AliITSdigit() { }
// returns the array size used to store Tracks and Hits
- // virtual Int_t GetNTracks() {return 0;}
+ static Int_t GetNTracks() {return fgkSize;}
//returns pointer to array of tracks numbers
- virtual Int_t *GetTracks() {return 0;}
+ virtual Int_t *GetTracks() {return &fTracks[0];}
// returns pointer to array of hits numbers for this module (as given by
// AliITSmodule).
- virtual Int_t *GetHits() {return 0;}
+ virtual Int_t *GetHits() {return &fHits[0];}
// returns track number kept in the array element i of fTracks
- virtual Int_t GetTrack(Int_t) const {return 0;}
+ virtual Int_t GetTrack(Int_t i) const {return fTracks[i];}
// returns hit number kept in the array element i of fHits
- virtual Int_t GetHit(Int_t) const {return 0;}
+ virtual Int_t GetHit(Int_t i) const {return fHits[i];}
virtual Int_t GetCoord1() const {return fCoord1;} // returns fCoord1
virtual Int_t GetCoord2() const {return fCoord2;} // returns fCoord2
virtual Int_t GetSignal() const {return fSignal;} // returns fSignal
virtual void SetCoord1(Int_t i){fCoord1 = i;} // Sets fCoord1 value
virtual void SetCoord2(Int_t i){fCoord2 = i;} // Sets fCoord12value
virtual void SetSignal(Int_t i){fSignal = i;} // Sets fSignal value
-
+ virtual void SetTrack(Int_t i,Int_t trk){fTracks[i]=trk;}
+ virtual void SetTracks(const Int_t *trks){
+ for(Int_t i=0;i<fgkSize;i++) fTracks[i]=trks[i];}
+ virtual void SetHit(Int_t i,Int_t hit){fHits[i]=hit;}
+ virtual void SetHits(const Int_t *hits){
+ for(Int_t i=0;i<fgkSize;i++) fHits[i]=hits[i];}
virtual void Print(Option_t *option="") const {TObject::Print(option);}
virtual void Print(ostream *os); // Class ascii print function
virtual Int_t Read(const char *name) {return TObject::Read(name);}
virtual void Read(istream *os); // Class ascii read function
protected:
+ static const Int_t fgkSize = 10;//array size
+ Int_t fTracks[fgkSize]; //[fgkSize] tracks making this digit
+ Int_t fHits[fgkSize]; //[fgkSize] hits associated to the tracks
+
Int_t fCoord1; // Cell number on Z axis (SPD+SDD), flag for side type (SSD)
Int_t fCoord2; // Cell number on X axis (SPD+SDD), strip number (SSD)
Int_t fSignal; // Signal in ADC counts
- ClassDef(AliITSdigit,1) // Real data digit object for set:ITS
+ ClassDef(AliITSdigit,2) // Real data digit object for set:ITS
};
// Input and output functions for standard C++ input/output.
// be a valide track of hit number.
Int_t i;
- for(i=0;i<fgkSsdd;i++) fTracks[i] = -3;
- for(i=0;i<fgkSsdd;i++) fHits[i] = -1;
- for(i=0;i<fgkSsdd;i++) fTcharges[i] = 0;
+ for(i=0;i<fgkSize;i++) fTracks[i] = -3;
+ for(i=0;i<fgkSize;i++) fHits[i] = -1;
+ for(i=0;i<fgkSize;i++) fTcharges[i] = 0;
SetSignalExpanded(-1000);
}
//________________________________________________________________________
fSignalExpanded(0){
// Creates a simulated SDD digit object to be updated
-
- SetSignalExpanded(-1000);
+ for(Int_t i=0;i<fgkSize;i++) fTracks[i] = -3;
+ for(Int_t i=0;i<fgkSize;i++) fHits[i] = -1;
+ for(Int_t i=0;i<fgkSize;i++) fTcharges[i] = 0;
+
+ SetSignalExpanded(-1000);
}
//________________________________________________________________________
// Protected function used by standard constructors
fPhysics = phys;
- for(Int_t i=0; i<fgkSsdd; i++) {
+ for(Int_t i=0; i<fgkSize; i++) {
fTcharges[i] = charges[i];
fTracks[i] = tracks[i];
fHits[i] = hits[i];
AliITSdigit::Print(os);
*os <<","<< fPhysics;
- for(i=0; i<fgkSsdd; i++) *os <<","<< fTcharges[i];
- for(i=0; i<fgkSsdd; i++) *os <<","<< fTracks[i];
- for(i=0; i<fgkSsdd; i++) *os <<","<< fHits[i];
+ for(i=0; i<fgkSize; i++) *os <<","<< fTcharges[i];
+ for(i=0; i<fgkSize; i++) *os <<","<< fTracks[i];
+ for(i=0; i<fgkSize; i++) *os <<","<< fHits[i];
*os <<","<< fSignalExpanded;
}
//______________________________________________________________________
AliITSdigit::Read(os);
*os >>fPhysics;
- for(i=0; i<fgkSsdd; i++) *os >> fTcharges[i];
- for(i=0; i<fgkSsdd; i++) *os >> fTracks[i];
- for(i=0; i<fgkSsdd; i++) *os >> fHits[i];
+ for(i=0; i<fgkSize; i++) *os >> fTcharges[i];
+ for(i=0; i<fgkSize; i++) *os >> fTracks[i];
+ for(i=0; i<fgkSize; i++) *os >> fHits[i];
*os >>fSignalExpanded;
}
//______________________________________________________________________
AliITSCalibrationSDD *resp);
virtual ~AliITSdigitSDD(){/* destructor*/}
// returns the array size used to store Tracks and Hits
- static Int_t GetNTracks() {return fgkSsdd;}
- // returns pointer to the array of tracks which make this digit
- virtual Int_t *GetTracks() {return &fTracks[0];}
- // returns the pointer to the array of hits which made this digit
- virtual Int_t *GetHits() {return &fHits[0];}
virtual Int_t GetSignal() const {return fSignalExpanded;}
virtual Int_t GetCompressedSignal() const {return fSignal;}
- // returns track number kept in the array element i of fTracks
- virtual Int_t GetTrack(Int_t i) const {return fTracks[i];}
- // returns hit number kept in the array element i of fHits
- virtual Int_t GetHit(Int_t i) const {return fHits[i];}
- // Return charge deposited by this track/hit
+ // Return charge deposited by this track/hit
virtual Float_t GetCharge(Int_t i) const {return fTcharges[i];}
// returns TArrayI of unduplicated track numbers (summed over hits).
virtual Int_t GetListOfTracks(TArrayI &t,TArrayF &c);
- //copy the array trks[fgkSsdd] into fTracks
- virtual void SetTracks(const Int_t *trks){
- for(Int_t i=0;i<fgkSsdd;i++) fTracks[i]=trks[i];}
- //copy the array hits[fgkSsdd] into fHits
- virtual void SetHits(const Int_t *hits){
- for(Int_t i=0;i<fgkSsdd;i++) fHits[i]=hits[i];}
- //set array element i of fTracks to trk.
- virtual void SetTrack(Int_t i,Int_t trk){fTracks[i]=trk;}
- //set array element i of fHits to hit.
- virtual void SetHit(Int_t i,Int_t hit){fHits[i]=hit;}
void SetSignalExpanded(Int_t sig){fSignalExpanded = sig;}
virtual void Print(ostream *os); // Class ascii print function
virtual void Read(istream *os); // Class ascii read function
protected:
void InitObject(Float_t phys,const Int_t *tracks,
const Int_t *hits,const Float_t *charges);
- static const Int_t fgkSsdd = 10; // size of fTracks and fHits arrays
- // debugging -- goes to the dictionary
- Int_t fTracks[fgkSsdd]; //[fgkSsdd] tracks making this digit
- Int_t fHits[fgkSsdd]; //[fgkSsdd] hits associated to the tracks
// 3 hits temporarily - it will be only 1
- Float_t fTcharges[fgkSsdd]; //[fgkSsdd] charge per track making this digit
+ Float_t fTcharges[fgkSize]; //[fgkSize] charge per track making this digit
Float_t fPhysics; // signal particles contribution to signal
Int_t fSignalExpanded; // 10 bit signal
- ClassDef(AliITSdigitSDD,3) // Simulated digit object for SDD
+ ClassDef(AliITSdigitSDD,4) // Simulated digit object for SDD
};
// Input and output functions for standard C++ input/output.
// be a valide track of hit number.
Int_t i;
- for(i=0;i<fgkSspd;i++) fTracks[i] = -3;
- for(i=0;i<fgkSspd;i++) fHits[i] = -1;
+ for(i=0;i<fgkSize;i++) fTracks[i] = -3;
+ for(i=0;i<fgkSize;i++) fHits[i] = -1;
}
//______________________________________________________________________
AliITSdigitSPD::AliITSdigitSPD(const Int_t *digits):
// Creates a SPD digit object
Int_t i;
- for(i=0;i<fgkSspd;i++) fTracks[i] = -3;
- for(i=0;i<fgkSspd;i++) fHits[i] = -1;
+ for(i=0;i<fgkSize;i++) fTracks[i] = -3;
+ for(i=0;i<fgkSize;i++) fHits[i] = -1;
fCoord1 = digits[0];
fCoord2 = digits[1];
fSignal = 1;
fSignalSPD(digits[2]){
// Creates a simulated SPD digit object
- for(Int_t i=0; i<fgkSspd; i++) {
+ for(Int_t i=0; i<fgkSize; i++) {
fTracks[i] = tracks[i];
fHits[i] = hits[i];
} // end for i
Int_t i;
AliITSdigit::Print(os);
- for(i=0;i<fgkSspd;i++) *os <<","<< fTracks[i];
- for(i=0;i<fgkSspd;i++) *os <<","<< fHits[i];
+ for(i=0;i<fgkSize;i++) *os <<","<< fTracks[i];
+ for(i=0;i<fgkSize;i++) *os <<","<< fHits[i];
*os << "," << fSignalSPD;
}
//______________________________________________________________________
Int_t i;
AliITSdigit::Read(os);
- for(i=0;i<fgkSspd;i++) *os >> fTracks[i];
- for(i=0;i<fgkSspd;i++) *os >> fHits[i];
+ for(i=0;i<fgkSize;i++) *os >> fTracks[i];
+ for(i=0;i<fgkSize;i++) *os >> fHits[i];
*os >> fSignalSPD;
}
//______________________________________________________________________
//standard creator with digits, tracks, and hits
AliITSdigitSPD(const Int_t *digits,const Int_t *tracks,const Int_t *hits);
virtual ~AliITSdigitSPD(){/*destructor*/}
- // returns the array size used to store Tracks and Hits
- static Int_t GetNTracks() {return fgkSspd;}
// returns the signal in electrons
Int_t GetSignalSPD() const {return fSignalSPD;}
- // returns pointer to the array of tracks which make this digit
- virtual Int_t *GetTracks() {return &fTracks[0];}
- //returns the pointer to the array of hits which made this digit
- virtual Int_t *GetHits() {return &fHits[0];}
- // returns track number kept in the array element i of fTracks
- virtual Int_t GetTrack(Int_t i) const {return fTracks[i];}
- // returns hit number kept in the array element i of fHits
- virtual Int_t GetHit(Int_t i) const {return fHits[i];}
- // returns TArrayI of unduplicated track numbers (summed over hits).
virtual Int_t GetListOfTracks(TArrayI &t);
- //copy the array trks[fgkSspd] into fTracks
- virtual void SetTracks(const Int_t *trks){
- for(Int_t i=0;i<fgkSspd;i++) fTracks[i]=trks[i];}
// set signal in electrons
void SetSignalSPD(Int_t sig) {fSignalSPD = sig;}
- //copy the array hits[fgkSspd] into fHits
- virtual void SetHits(const Int_t *hits){
- for(Int_t i=0;i<fgkSspd;i++) fHits[i]=hits[i];}
- //set array element i of fTracks to trk.
- virtual void SetTrack(Int_t i,Int_t trk){fTracks[i]=trk;}
- //set array element i of fHits to hit.
- virtual void SetHit(Int_t i,Int_t hit){fHits[i]=hit;}
virtual void Print(ostream *os); // Class ascii print function
virtual void Print(Option_t *option="") const {TObject::Print(option);}
virtual void Read(istream *os); // Class ascii read function
virtual Int_t Read(const char *name) {return TObject::Read(name);}
protected:
- static const Int_t fgkSspd = 10; // size of fTracks and fHits arrays
- // debugging -- goes to the dictionary
- Int_t fTracks[fgkSspd]; //[fgkSspd] tracks making this digit
- Int_t fHits[fgkSspd]; //[fgkSspd] hits associated to the tracks
Int_t fSignalSPD; // Signal in electrons
- ClassDef(AliITSdigitSPD,2) // Simulated digit object for SPD
+ ClassDef(AliITSdigitSPD,3) // Simulated digit object for SPD
};
// Input and output functions for standard C++ input/output.
// default constructor
Int_t i;
- for(i=0; i<fgkSssd; i++) fTracks[i] = -3;
- for(i=0; i<fgkSssd; i++) fHits[i] = -1;
+ for(i=0; i<fgkSize; i++) fTracks[i] = -3;
+ for(i=0; i<fgkSize; i++) fHits[i] = -1;
}
//__________________________________________________________________________
AliITSdigitSSD::AliITSdigitSSD(const Int_t *digits):AliITSdigit(digits){
const Int_t *hits):AliITSdigit(digits){
// Creates a simulated SSD digit object
- for(Int_t i=0; i<fgkSssd; i++) {
+ for(Int_t i=0; i<fgkSize; i++) {
fTracks[i] = tracks[i];
fHits[i] = hits[i];
} // end for i
Int_t i;
AliITSdigit::Print(os);
- for(i=0; i<fgkSssd; i++) *os <<","<< fTracks[i];
- for(i=0; i<fgkSssd; i++) *os <<","<< fHits[i];
+ for(i=0; i<fgkSize; i++) *os <<","<< fTracks[i];
+ for(i=0; i<fgkSize; i++) *os <<","<< fHits[i];
}
//______________________________________________________________________
void AliITSdigitSSD::Read(istream *os){
Int_t i;
AliITSdigit::Read(os);
- for(i=0; i<fgkSssd; i++) *os >> fTracks[i];
- for(i=0; i<fgkSssd; i++) *os >> fHits[i];
+ for(i=0; i<fgkSize; i++) *os >> fTracks[i];
+ for(i=0; i<fgkSize; i++) *os >> fHits[i];
}
//______________________________________________________________________
ostream &operator<<(ostream &os,AliITSdigitSSD &source){
AliITSdigitSSD(const Int_t *digits,const Int_t *tracks,const Int_t *hits);
virtual ~AliITSdigitSSD(){/* destructor */}
// returns the array size used to store Tracks and Hits
- static Int_t GetNTracks() {return fgkSssd;}
+ // static Int_t GetNTracks() {return fgkSssd;}
Int_t GetSignal() const {/* returns signal*/return fSignal;}
Int_t GetStripNumber() const {/* returns strip number*/return fCoord2;}
//returns 1 when side P and 0 when side N
Int_t IsSideP() const {if(fCoord1==0) return 1; else return 0; }
- // returns pointer to the array of tracks which make this digit
- virtual Int_t *GetTracks() {return &fTracks[0];}
// returns the pointer to the array of hits which made this digit
- virtual Int_t *GetHits() {return &fHits[0];}
- // returns track number kept in the array element i of fTracks
- virtual Int_t GetTrack(Int_t i) const {return fTracks[i];}
- // returns hit number kept in the array element i of fHits
- virtual Int_t GetHit(Int_t i) const {return fHits[i];}
// returns TArrayI of unduplicated track numbers (summed over hits).
virtual Int_t GetListOfTracks(TArrayI &t);
- //copy the array trks[fgkSssd] into fTracks
- virtual void SetTracks(const Int_t *trks){
- for(Int_t i=0;i<fgkSssd;i++) fTracks[i]=trks[i];}
- //copy the array hits[fgkSssd] into fHits
- virtual void SetHits(const Int_t *hits){
- for(Int_t i=0;i<fgkSssd;i++) fHits[i]=hits[i];}
- //set array element i of fTracks to trk.
- virtual void SetTrack(Int_t i,Int_t trk){fTracks[i]=trk;}
- //set array element i of fHits to hit.
- virtual void SetHit(Int_t i,Int_t hit){fHits[i]=hit;}
void Print(ostream *os); // Class ascii print function
void Read(istream *os); // Class ascii read function
virtual void Print(Option_t *option="") const {TObject::Print(option);}
protected:
- static const Int_t fgkSssd = 10; // size of fTracks and fHits arrays
- // debugging -- goes to the dictionary
- Int_t fTracks[fgkSssd]; //[fgkSssd] tracks making this digit
- Int_t fHits[fgkSssd]; //[fgkSssd] hits associated to the tracks
- // 3 hits temporarily - it will be only 1
- ClassDef(AliITSdigitSSD,2) // Simulated digit object for SSD
+ ClassDef(AliITSdigitSSD,3) // Simulated digit object for SSD
};
// Input and output functions for standard C++ input/output.
#include <TFile.h>
#include <TRandom.h>
#include <TROOT.h>
-
#include "AliITS.h"
#include "AliITSMapA2.h"
#include "AliITSRawData.h"
//____________________________________________
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];
//______________________________________________________________________
void AliITSsimulationSDD::ZeroSuppression(const char *option) {
// perform the zero suppresion
-
if (strstr(option,"2D")) {
//Init2D(); // activate if param change module by module
Compress2D();
digits[1] = j;
digits[2] = signal;
fITS->AddRealDigit(1,digits);
- } // end for j
+ } // end for j
} // end for i
}
//______________________________________________________________________
Int_t j,ix,iz;
Double_t electronics;
Double_t sig;
- const Int_t knmaxtrk=AliITSdigitSPD::GetNTracks();
+ const Int_t knmaxtrk=AliITSdigit::GetNTracks();
static AliITSdigitSPD dig;
AliITSCalibrationSPD* res = (AliITSCalibrationSPD*)GetCalibrationModel(fDetType->GetITSgeom()->GetStartSPD());
if(GetDebug(1)) Info("FrompListToDigits","()");