**************************************************************************/
#include "AliITSClusterFinder.h"
+#include "AliITSdigit.h"
#include "AliRun.h"
#include "AliITS.h"
fNRawClusters++;
iTS->AddRecPoint(rp);
}
+//______________________________________________________________________
+void AliITSClusterFinder::FindRawClusters(Int_t module){
+ // Default Cluster finder.
+ // Input:
+ // Int_t module Module number for which culster are to be found.
+ // Output:
+ // none.
+ // Return:
+ // none.
+ const Int_t kelms = 10;
+ Int_t ndigits = fDigits->GetEntriesFast();
+ TObjArray *digs = new TObjArray(ndigits);
+ TObjArray *clusts = new TObjArray(ndigits); // max # cluster
+ TObjArray *clust0=0; // A spacific cluster of digits
+ TObjArray *clust1=0; // A spacific cluster of digits
+ AliITSdigit *dig=0; // locat pointer to a digit
+ Int_t i=0,nc=0,j[4],k,k2;
+
+ // Copy all digits for this module into a local TObjArray.
+ for(i=0;i<ndigits;i++) digs->AddAt(new AliITSdigit(*((AliITSdigit*)(fDigits->At(i)))),i);
+ digs->Sort();
+ // First digit is a cluster.
+ i = 0;
+ nc = 0;
+ clusts->AddAt(new TObjArray(kelms),nc);
+ clust0 = (TObjArray*)(clusts->At(nc));
+ clust0->AddAtFree(digs->At(i)); // move owner ship from digs to clusts
+ nc++;
+ for(i=1;i<ndigits;i++){
+ if(IsNeighbor(digs,i,j)){
+ dig = (AliITSdigit*)(digs->At(j[0]));
+ // Add to existing cluster. Find which cluster this digis
+ for(k=0;k<nc;k++){
+ clust0 = ((TObjArray*)(clusts->At(k)));
+ if(clust0->IndexOf(dig)>=0) break;
+ } // end for k
+ if(k>=nc){
+ Error("FindRawClusters","Digit not found as expected");
+ abort();
+ } // end if
+ if(j[1]>=0){
+ dig = (AliITSdigit*)(digs->At(j[1]));
+ // Add to existing cluster. Find which cluster this digis
+ for(k2=0;k2<nc;k2++){
+ clust1 = ((TObjArray*)(clusts->At(k2)));
+ if(clust1->IndexOf(dig)>=0) break;
+ } // end for k2
+ if(k2>=nc){
+ Error("FindRawClusters","Digit not found as expected");
+ abort();
+ } // end if
+ } // end if j[1]>=0
+ // Found cluster with neighboring digits add this one to it.
+ if(clust0==clust1){ // same cluster
+ clust0->AddAtFree(digs->At(i));
+ clust0 = 0; // finished with cluster. zero for safty
+ clust1 = 0; // finished wit hcluster. zero for safty
+ }else{ // two different clusters which need to be merged.
+ clust0->AddAtFree(digs->At(i)); // Add digit to this cluster.
+ for(k=0;k<clust1->GetEntriesFast();k++){
+ // move clust1 into clust0
+ clust0->AddAtFree(clust1->At(k));//move digit to this cluster
+ clust1->AddAt(0,k); // zero this one
+ } // end for k
+ delete clust1;
+ clusts->AddAt(0,k2); // zero array of clusters element clust1
+ clust0 = 0; // finished with cluster. zero for safty
+ clust1 = 0; // finished wit hcluster. zero for safty
+ } // end if clust0==clust1
+ }else{// New cluster
+ clusts->AddAt(new TObjArray(kelms),nc);
+ clust0 = ((TObjArray*)(clusts->At(nc)));
+ clust0->AddAtFree(digs->At(i));// move owner ship from digs to clusts
+ clust0 = 0; // finished with cluster. zero for safty
+ nc++;
+ } // End if IsNeighbor
+ } // end for i
+ // There are now nc clusters in clusts. Each element of clust is an
+ // array of digits which are clustered together.
+
+ // For each cluster call detector specific CreateRecPoints
+ for(i=0;i<nc;i++) CreateRecPoints((TObjArray*)(clusts->At(i)),module);
+
+ // clean up at the end.
+ for(i=0;i<nc;i++){
+ clust0 =(TObjArray*)(clusts->At(i));
+ // Digits deleted below, so zero this TObjArray
+ for(k=0;k<clust0->GetEntriesFast();k++) clust0->AddAt(0,k);
+ delete clust0; // Delete this TObjArray
+ clusts->AddAt(0,i); // Contents deleted above, so zero it.
+ } // end for i
+ delete clusts; // Delete this TObjArray/
+ // Delete the digits then the TObjArray which containted them.
+ for(i=0;i<ndigits;i++) delete ((AliITSdigit*)(digs->At(i)));
+ delete digs;
+}
+//______________________________________________________________________
+Bool_t AliITSClusterFinder::IsNeighbor(TObjArray *digs,Int_t i,Int_t n[]){
+ // Locagical function which checks to see if digit i has a neighbor.
+ // If so, then it returns kTRUE and its neighbor index j.
+ // This routine checks if the digits are side by side or one before the
+ // other. Requires that the array of digits be in proper order.
+ // Returns kTRUE in the following cases.
+ // ji 0j if kdiagonal j0 0i
+ // 00 0i if kdiagonal 0i j0
+ // Inputs:
+ // TObjArray *digs Array to search for neighbors in
+ // Int_t i Index of digit for which we are searching for
+ // a neighbor of.
+ // Output:
+ // Int_t j[4] Index of one or more of the digits which is a
+ // neighbor of digit a index i.
+ // Return:
+ // Bool_t kTRUE if a neighbor was found kFALSE otherwise.
+ Int_t ix,jx,iz,jz,j;
+ const Bool_t kdiagonal=kFALSE;
+ Bool_t nei[4];
+
+ // No neighbors found if array empty.
+ if(digs->GetEntriesFast()<=0) return kFALSE;
+ // can not be a digit with first element or elements out or range
+ if(i<=0 || i>=digs->GetEntriesFast()) return kFALSE;
+
+ for(j=0;j<4;j++){n[j] = -1;nei[j]=kFALSE;}
+ ix = ((AliITSdigit*)(digs->At(i)))->GetCoord1();
+ iz = ((AliITSdigit*)(digs->At(i)))->GetCoord2();
+ for(j=0;j<i;j++){
+ jx = ((AliITSdigit*)(digs->At(j)))->GetCoord1();
+ jz = ((AliITSdigit*)(digs->At(j)))->GetCoord2();
+ if(jx+1==ix && jz ==iz){n[0] = j;nei[0] = kTRUE;}
+ if(jx ==ix && jz+1==iz){n[1] = j;nei[1] = kTRUE;}
+ if(jx+1==ix && jz+1==iz){n[2] = j;nei[2] = kTRUE;}
+ if(jx+1==ix && jz-1==iz){n[3] = j;nei[3] = kTRUE;}
+ } // end for k
+ if(nei[0]||nei[1]) return kTRUE;
+ if(kdiagonal&&(nei[2]||nei[3])) return kTRUE;
+ // no Neighbors found.
+ return kFALSE;
+}
virtual void AddCluster(Int_t branch, AliITSRawCluster *c);
virtual void AddCluster(Int_t branch, AliITSRawCluster *c,
AliITSRecPoint &rp);
- virtual void FindRawClusters(Int_t mod=0) {
- // Search for raw clusters
- }
+ virtual void FindRawClusters(Int_t mod=0); // Finds cluster of digits.
+ // Determins if digit i has a neighbor and if so that neighor index is j.
+ virtual Bool_t IsNeighbor(TObjArray *digs,Int_t i,Int_t j[]);
+ // Given a cluster of digits, creates the nessesary RecPoint. May also
+ // do some peak separation.
+ virtual void CreateRecPoints(TObjArray *cluster,Int_t mod){};
virtual void FindCluster(Int_t i, Int_t j, AliITSRawCluster *c) {
// find cluster
}
/*
$Id$
$Log$
+ Revision 1.28 2002/10/22 14:45:29 alibrary
+ Introducing Riostream.h
+
Revision 1.27 2002/10/14 14:57:00 hristov
Merging the VirtualMC branch to the main development branch (HEAD)
j<dig->GetNTracks()) j++;
if(j<dig->GetNTracks()){
rnew.fTracks[1] = dig->fTracks[j];
- while(rnew.fTracks[1]==dig->fTracks[j] &&
+ while((rnew.fTracks[0]==dig->fTracks[j] ||
+ rnew.fTracks[1]==dig->fTracks[j] )&&
j<dig->GetNTracks()) j++;
if(j<dig->GetNTracks()) rnew.fTracks[2] = dig->fTracks[j];
} // end if
AliITSdigitSPD *dig;
Int_t ndig,i;
+// cout << "FindRawcluters"<<endl;
+// scanf("%d",ndig);
for(ndig=0; ndig<ndigits; ndig++) {
dig= (AliITSdigitSPD*)fDigits->UncheckedAt(ndig);
digx[digitcount] = dig->fCoord2+1; //starts at 1
digtr1[digitcount] = dig->fTracks[0];
digtr2[digitcount] = -3;
digtr3[digitcount] = -3;
+ //cout << "digtr1["<<digitcount <<"]="<<digtr1[digitcount];
+ //cout << " fTracks["<<0<<"]="<<dig->fTracks[0]<<": ";
i=1;
while(digtr1[digitcount]==dig->fTracks[i] && i<dig->GetNTracks()) i++;
+ //cout << " fTracks["<<i<<"]="<<dig->fTracks[i];
if(i<dig->GetNTracks()){
digtr2[digitcount] = dig->fTracks[i];
- while(digtr1[digitcount]==dig->fTracks[i] &&
- i<dig->GetNTracks()) i++;
+ //cout << "digtr2["<<digitcount <<"]="<<digtr2[digitcount]<<": ";
+ while((digtr1[digitcount]==dig->fTracks[i] ||
+ digtr2[digitcount]==dig->fTracks[i] )&&
+ i<=dig->GetNTracks()) i++;
if(i<dig->GetNTracks()) digtr3[digitcount] = dig->fTracks[i];
+ //cout << " fTracks["<<i<<"]=";
+ //if(i<dig->GetNTracks()) cout <<dig->fTracks[i];
+ //cout << "digtr3["<<digitcount <<"]="<<digtr3[digitcount];
} // end if
+ //cout<<endl;
digtr4[digitcount] = dig->fSignal;
digitcount++;
} // end for ndig
/*
$Log$
+Revision 1.6 2002/10/22 14:45:34 alibrary
+Introducing Riostream.h
+
Revision 1.5 2002/10/14 14:57:00 hristov
Merging the VirtualMC branch to the main development branch (HEAD)
fInit = kTRUE; // Assume for now init will work.
if(!gAlice) {
fITS = 0;
- fActive = 0;
- fRoif = -1;
fRoiifile = 0;
fInit = kFALSE;
Warning("Init","gAlice not found");
} // end if
fITS = (AliITS *)(gAlice->GetDetector("ITS"));
if(!fITS){
- fActive = 0;
- fRoif = -1;
fRoiifile = 0;
fInit = kFALSE;
Warning("Init","ITS not found");
//cout << "fRoif,fRoiifile="<<fRoif<<" "<<fRoiifile<<endl;
fActive = new Bool_t[fITS->GetITSgeom()->GetIndexMax()];
} else{
- fActive = 0;
- fRoif = -1;
fRoiifile = 0;
fInit = kFALSE;
Warning("Init","ITS geometry not found");
// Digitize
fITS->MakeBranchInTreeD(GetManager()->GetTreeD());
+ if(fRoif!=0) Info("AliITSDigitizer","Region of Interest digitization selected");
+ else Info("AliITSDigitizer","No Region of Interest selected. Digitizing everything");
+ //cout <<"fActive="<<fActive<<" fRoif="<<fRoif;
+ if(fActive==0) fRoif = 0; // fActive array must be define for RIO cuts.
+ //cout <<" fRoif="<<fRoif<<endl;
for(module=0; module<size; module++ ){
- if(fActive && fRoif!=0) if(!fActive[module]) continue;
+ if(fRoif!=0) if(!fActive[module]) continue;
id = fITS->GetITSgeom()->GetModuleType(module);
if(!all && !det[id]) continue;
iDetType = fITS->DetType( id );
sim->InitSimulationModule(module, event);
//cout << "Module=" << module;
for(ifiles=0; ifiles<nfiles; ifiles++ ){
- if(fActive && fRoif!=0) if(!fActive[module]) continue;
+ if(fRoif!=0) if(!fActive[module]) continue;
//cout <<" fl[ifiles=" << ifiles << "]=" << fl[ifiles];
TTree *treeS = GetManager()->GetInputTreeS(fl[ifiles]);
if( !(treeS && fITS->GetSDigits()) ) continue;
//cout << fActive[m];
//cout << endl;
} // end for m
+ Info("AliITSDigitizer","Digitization by Region of Interest selected");
sdig->Clear();
delete sdig;
return;
} // end if
// manager->SetCopyTreesFromInput(0);
AliITSDigitizer *dITS = new AliITSDigitizer(manager);
- if(opt.Contains("ROI")==0) dITS->SetByRegionOfInterestFlag(1);
+ if(opt.Contains("ROI")){
+ cout << "Region of Interest selected" << endl;
+ dITS->SetByRegionOfInterestFlag(1);
+ }else{
+ cout << "Digizing everthing" << endl;
+ dITS->SetByRegionOfInterestFlag(0);
+ } // end if
TStopwatch timer;
timer.Start();
virtual ~AliITSRecPoint() {}; // distructor
Bool_t IsSortable() const {return kTRUE;} // allows for sorting
Int_t GetLabel(Int_t i) const {return fTracks[i];} // get track label
+ Int_t *GetTracks(){return fTracks;}// Returns pointer to track array
+ Int_t GetNTracks(){return 3;} // returns track array size
Float_t GetX() const {return fX;} // gets fX
Float_t GetZ() const {return fZ;} // gets fZ
Float_t GetQ() const {return fQ;} // gets fQ
/*
$Log$
+Revision 1.10 2002/10/22 14:45:37 alibrary
+Introducing Riostream.h
+
Revision 1.9 2002/10/14 14:57:00 hristov
Merging the VirtualMC branch to the main development branch (HEAD)
//______________________________________________________________________
Int_t *AliITSclusterSSD::GetTracks(Int_t &nt){
// return the track number of the cluster
+ Int_t ntrk = GetDigit(0)->GetNTracks();
+ Int_t ndig = GetNumOfDigits();
+ Int_t *idig = new Int_t[ndig];
+ Int_t *sdig = new Int_t[ndig];
+ Int_t *itrk = new Int_t[ndig*ntrk];
+ Int_t i,j,k,l,trk;
+ Bool_t b;
+
+ for(i=0;i<ndig;i++){idig[i] = i;sdig[i] = GetDigit(i)->GetSignal();}
+ TMath::Sort(ndig,sdig,idig,kTRUE);
+ for(i=0;i<ndig*ntrk;i++) itrk[i] = -3;
+ j = k = l = 0;
+ for(i=0;i<ndig;i++){ // fill itrk with track numbers in order of digit size
+ j = idig[i];
+ for(k=0;k<ntrk;k++) if((trk = GetDigit(j)->GetTrack(k))>=0) {
+ itrk[l] = trk;
+ l++;
+ } // end for k/if
+ } // end for i
+ for(i=0;i<10;i++) fTrack[i] = -3;
+ fTrack[0] = itrk[0]; // first element
+ k = 1;
+ b = kTRUE;
+ for(i=1;i<l;i++){
+ for(j=0;j<k;j++) if(fTrack[j]==itrk[i]) b = kFALSE;
+ if(b){fTrack[k] = itrk[i]; k++;}
+ if(k>9) break;
+ } // end for i
+ nt = k;
+
+ delete[] idig;
+ delete[] sdig;
+ delete[] itrk;
+
+ return fTrack;
+/*
Int_t *tidx=0;
Int_t i, j,n;
Int_t bit =0;
SetNTracks(ntracks);
nt = ntracks;
return &(fTrack[0]);
+*/
}
//______________________________________________________________________
Double_t AliITSclusterSSD::GetPosition(){
Int_t i;
for(i=0;i<fkSspd;i++) fTracks[i] = -3;
- for(i=0;i<fkSspd;i++) fHits[0] = -1;
+ for(i=0;i<fkSspd;i++) fHits[i] = -1;
}
//______________________________________________________________________
AliITSdigitSPD::AliITSdigitSPD(const Int_t *digits){
Int_t i;
for(i=0;i<fkSspd;i++) fTracks[i] = -3;
- for(i=0;i<fkSspd;i++) fHits[0] = -1;
+ for(i=0;i<fkSspd;i++) fHits[i] = -1;
fCoord1 = digits[0];
fCoord2 = digits[1];
fSignal = 1;
Int_t i;
for(i=0;i<fkSsdd;i++) fTracks[i] = -3;
- for(i=0;i<fkSsdd;i++) fHits[1] = -1;
+ for(i=0;i<fkSsdd;i++) fHits[i] = -1;
fPhysics = 0;
for(i=0;i<fkSsdd;i++) fTcharges[i] = 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 i) const {return fHits[i];}
- //copy the array trks[3] into fTracks
+ //copy the array trks[fkSspd] into fTracks
virtual void SetTracks(const Int_t *trks){
- for(Int_t i=0;i<3;i++) fTracks[i]=trks[i];}
- //copy the array hits[3] into fHits
+ for(Int_t i=0;i<fkSspd;i++) fTracks[i]=trks[i];}
+ //copy the array hits[fkSspd] into fHits
virtual void SetHits(const Int_t *hits){
- for(Int_t i=0;i<3;i++) fHits[i]=hits[i];}
+ for(Int_t i=0;i<fkSspd;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 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];}
- //copy the array trks[3] into fTracks
+ //copy the array trks[fkSsdd] into fTracks
virtual void SetTracks(const Int_t *trks){
- for(Int_t i=0;i<3;i++) fTracks[i]=trks[i];}
- //copy the array hits[3] into fHits
+ for(Int_t i=0;i<fkSsdd;i++) fTracks[i]=trks[i];}
+ //copy the array hits[fkSsdd] into fHits
virtual void SetHits(const Int_t *hits){
- for(Int_t i=0;i<3;i++) fHits[i]=hits[i];}
+ for(Int_t i=0;i<fkSsdd;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 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];}
- //copy the array trks[3] into fTracks
+ //copy the array trks[fkSssd] into fTracks
virtual void SetTracks(const Int_t *trks){
- for(Int_t i=0;i<3;i++) fTracks[i]=trks[i];}
- //copy the array hits[3] into fHits
+ for(Int_t i=0;i<fkSssd;i++) fTracks[i]=trks[i];}
+ //copy the array hits[fkSssd] into fHits
virtual void SetHits(const Int_t *hits){
- for(Int_t i=0;i<3;i++) fHits[i]=hits[i];}
+ for(Int_t i=0;i<fkSssd;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.
// none.
// Return:
// A copied AliITSpListItem object
+ Int_t i;
if(this == &source) return *this;
this->fmodule = source.fmodule;
this->findex = source.findex;
- for(Int_t i=0;i<this->fkSize;i++){
+ for(i=0;i<this->fkSize;i++){
this->fTrack[i] = source.fTrack[i];
this->fSignal[i] = source.fSignal[i];
this->fHits[i] = source.fHits[i];
this->fTsignal = source.fTsignal;
this->fNoise = source.fNoise;
this->fSignalAfterElect = source.fSignalAfterElect;
-
+ /*
+ cout <<"this fTrack[0-9]=";
+ for(i=0;i<this->fkSize;i++) cout <<this->fTrack[i]<<",";
+ cout <<" fHits[0-9]=";
+ for(i=0;i<this->fkSize;i++) cout <<this->fHits[i]<<",";
+ cout <<" fSignal[0-9]=";
+ for(i=0;i<this->fkSize;i++) cout <<this->fSignal[i]<<",";
+ cout << endl;
+ cout <<"source fTrack[0-9]=";
+ for(i=0;i<this->fkSize;i++) cout <<source.fTrack[i]<<",";
+ cout <<" fHits[0-9]=";
+ for(i=0;i<this->fkSize;i++) cout <<source.fHits[i]<<",";
+ cout <<" fSignal[0-9]=";
+ for(i=0;i<this->fkSize;i++) cout <<source.fSignal[i]<<",";
+ cout << endl;
+ */
return *this;
}
//______________________________________________________________________
fSignal[i] += signal;
flg = kTRUE;
} // end for i & if.
+ //cout << "track="<<track<<endl;
if(flg){ // resort arrays.
for(i=1;i<fkSize;i++){
j = i;
fTrack[j] = trk;
fHits[j] = hts;
fSignal[j] = sig;
+ //cout << "#fTrack["<<j-1<<"]="<<fTrack[j-1]<< " fTrack["<<
+ // j<<"]="<<fTrack[j]<<endl;
j--;
} // end while
} // end if i
fHits[i+1] = hit;
return; // put it in the right place, now exit.
} // end if
+ //cout << "$fTrack["<<i+1<<"]="<<fTrack[i+1]<< " fTrack["<<i<<"]="
+ //<<fTrack[i]<< " fHits["<<i+1<<"]="<<fHits[i+1]<< " fHits["<<i<<"]="
+ //<<fHits[i]<< " fSignal["<<i+1<<"]="<<fSignal[i+1]<< " fSignal["<<i
+ //<<"]="<<fSignal[i]<<endl;
} // end if; end for i
// Still haven't found the right place. Must be at top of list.
fSignal[0] = signal;
fTrack[0] = track;
fHits[0] = hit;
+ //cout << "$fTrack["<<0<<"]="<<fTrack[0]<<" fHits["<<0<<"]="<<fHits[0]
+ //<<" fSignal["<<0<<"]="<<fSignal[0]<<endl;
return;
}
//______________________________________________________________________
virtual AliITSpListItem& operator=(const AliITSpListItem &source);
// Returns the signal value in the list of signals
virtual Double_t GetSignal(Int_t i){
- return ( (i>=0&&i<fkSize-1) ? fSignal[i] : 0.0);}
+ return ( (i>=0&&i<fkSize) ? fSignal[i] : 0.0);}
virtual Double_t GetSignal(){
return fTsignal;}
virtual Double_t GetSignalAfterElect(){
virtual void AddNoise(Int_t module,Int_t index,Double_t noise);
// Returns track number.
virtual Int_t GetTrack(Int_t i){
- return ((i>=0&&i<fkSize-1) ? fTrack[i] : 0);}
+ return ((i>=0&&i<fkSize) ? fTrack[i] : 0);}
// Returns hit number.
virtual Int_t GetHit(Int_t i){
- return ((i>=0&&i<fkSize-1) ? fHits[i] : 0);}
+ return ((i>=0&&i<fkSize) ? fHits[i] : 0);}
// Returns module number.
virtual Int_t GetModule(){
return fmodule;}
const Float_t kconv=10000; // cm->um
+ x *= kconv; // Convert to microns
+ z *= kconv; // Convert to microns
Int_t na = fNanodes/2;
- Float_t driftpath=fDx-TMath::Abs(kconv*x);
+ Float_t driftpath=fDx-TMath::Abs(x);
timebin=(Int_t)(driftpath/fDriftSpeed/fTimeStep);
- anode=(Int_t)(kconv*z/fPitch + na/2);
+ anode=(Int_t)(z/fPitch + na/2);
if (x > 0) anode += na;
timebin+=1;
/*
$Log$
+Revision 1.22 2002/10/22 14:45:44 alibrary
+Introducing Riostream.h
+
Revision 1.21 2002/10/14 14:57:08 hristov
Merging the VirtualMC branch to the main development branch (HEAD)
Int_t idhit,Int_t module,
AliITSpList *pList) {
// Take into account the coupling between adiacent pixels.
+ // The parameters probcol and probrow are the probability of the
+ // signal in one pixel shared in the two adjacent pixels along
+ // the column and row direction, respectively.
+ //
+ //Begin_Html
+ /*
+ <img src="picts/ITS/barimodel_3.gif">
+ </pre>
+ <br clear=left>
+ <font size=+2 color=red>
+ <a href="mailto:tiziano.virgili@cern.ch"></a>.
+ </font>
+ <pre>
+ */
+ //End_Html
+ Int_t j1,j2,flag=0;
+ Double_t pulse1,pulse2;
+ Float_t couplR=0.0,couplC=0.0;
+ Double_t xr=0.;
+
+ GetCouplings(couplR,couplC);
+ j1 = row;
+ j2 = col;
+ pulse1 = fMapA2->GetSignal(row,col);
+ pulse2 = pulse1;
+ for (Int_t isign=-1;isign<=1;isign+=2){// loop in row direction
+ do{
+ j1 += isign;
+ // pulse1 *= couplR;
+ xr = gRandom->Rndm();
+ // if ((j1<0) || (j1>GetNPixelsZ()-1) || (pulse1<GetThreshold())){
+ if ((j1<0) || (j1>GetNPixelsZ()-1) || (xr>couplR)){
+ j1 = row;
+ flag = 1;
+ }else{
+ UpdateMapSignal(j1,col,ntrack,idhit,module,pulse1,pList);
+ // flag = 0;
+ flag = 1; // only first next!!
+ } // end if
+ } while(flag == 0);
+ // loop in column direction
+ do{
+ j2 += isign;
+ // pulse2 *= couplC;
+ xr = gRandom->Rndm();
+ // if ((j2<0) || (j2>(GetNPixelsX()-1)) || (pulse2<GetThreshold())){
+ if ((j2<0) || (j2>GetNPixelsX()-1) || (xr>couplC)){
+ j2 = col;
+ flag = 1;
+ }else{
+ UpdateMapSignal(row,j2,ntrack,idhit,module,pulse2,pList);
+ // flag = 0;
+ flag = 1; // only first next!!
+ } // end if
+ } while(flag == 0);
+ } // for isign
+}
+//______________________________________________________________________
+void AliITSsimulationSPD::SetCouplingOld(Int_t row, Int_t col, Int_t ntrack,
+ Int_t idhit,Int_t module,
+ AliITSpList *pList) {
+ // Take into account the coupling between adiacent pixels.
// The parameters probcol and probrow are the fractions of the
// signal in one pixel shared in the two adjacent pixels along
// the column and row direction, respectively.
Float_t * charges = new Float_t[size];
Int_t j1;
+ for(j1=0;j1<size;j1++){tracks[j1]=-3;hits[j1]=-1;charges[j1]=0.0;}
for (Int_t r=1;r<=GetNPixelsZ();r++) {
for (Int_t c=1;c<=GetNPixelsX();c++) {
// check if the deposited energy in a pixel is above the
if(j1<pList->GetNEnteries()){
tracks[j1] = pList->GetTrack(r,c,j1);
hits[j1] = pList->GetHit(r,c,j1);
- }else{
- tracks[j1] = -3;
- hits[j1] = -1;
+ //}else{
+ //tracks[j1] = -3;
+ //hits[j1] = -1;
} // end if
- charges[j1] = 0;
+ //charges[j1] = 0;
} // end for j1
Float_t phys = 0;
aliITS->AddSimDigit(0,phys,digits,tracks,hits,charges);
// Take into account the coupling between adiacent pixels.
// The parameters probcol and probrow are the fractions of the
// signal in one pixel shared in the two adjacent pixels along
- // the column and row direction, respectively.
+ // the column and row direction, respectively. Now done in a statistical
+ // way and not "mechanical" as in the Old version.
void SetCoupling(Int_t row,Int_t col,Int_t ntrack,Int_t idhit,Int_t module,
AliITSpList *pList);
+ // Take into account the coupling between adiacent pixels.
+ // The parameters probcol and probrow are the fractions of the
+ // signal in one pixel shared in the two adjacent pixels along
+ // the column and row direction, respectively.
+ void SetCouplingOld(Int_t row,Int_t col,Int_t ntrack,Int_t idhit,
+ Int_t module,AliITSpList *pList);
// The pixels are fired if the energy deposited inside them is above
// the threshold parameter ethr. Fired pixed are interpreted as digits
// and stored in the file digitfilename. One also needs to write out
void GetThresholds(Float_t &t,Float_t &s){
((AliITSresponseSPD*)fResponse)->Thresholds(t,s);}
// Returns the couplings Columb and Row.
- void GetCouplings(Float_t &cc,Float_t cr){
+ void GetCouplings(Float_t &cc,Float_t &cr){
((AliITSresponseSPD*)fResponse)->GetNoiseParam(cc,cr);}
// Returns the number of pixels in x
Int_t GetNPixelsX(){return ((AliITSsegmentationSPD*)fSegmentation)->Npx();}
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff