]> git.uio.no Git - u/mrichter/AliRoot.git/blame - ITS/AliITSClusterFinder.cxx
A problem with endianity fixed (thanks to F. Carminati)
[u/mrichter/AliRoot.git] / ITS / AliITSClusterFinder.cxx
CommitLineData
b0f5e3fc 1/**************************************************************************
2 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
3 * *
4 * Author: The ALICE Off-line Project. *
5 * Contributors are mentioned in the code where appropriate. *
6 * *
7 * Permission to use, copy, modify and distribute this software and its *
8 * documentation strictly for non-commercial purposes is hereby granted *
9 * without fee, provided that the above copyright notice appears in all *
10 * copies and that both the copyright notice and this permission notice *
11 * appear in the supporting documentation. The authors make no claims *
12 * about the suitability of this software for any purpose. It is *
13 * provided "as is" without express or implied warranty. *
14 **************************************************************************/
bf3f2830 15//
16// Base Class used to find
17// the reconstructed points for ITS
18// See also AliITSClusterFinderSPD, AliITSClusterFinderSDD,
19// AliITSClusterFinderSDD
20//
88cb7938 21
b0f5e3fc 22#include "AliITSClusterFinder.h"
f8d9a5b8 23#include "AliITSdigit.h"
b0f5e3fc 24#include "AliRun.h"
e8189707 25#include "AliITS.h"
b0f5e3fc 26
b0f5e3fc 27ClassImp(AliITSClusterFinder)
28
9de0700b 29//----------------------------------------------------------------------
30AliITSClusterFinder::AliITSClusterFinder(){
31 // default cluster finder
32
33 fSegmentation = 0;
34 fResponse = 0;
35 fMap = 0;
36 fDigits = 0;
37 fNdigits = 0;
38 fNRawClusters = 0;
39 fNperMax = 0;
40 fDeclusterFlag= 0;
41 fClusterSize = 0;
42 fNPeaks = 0;
43}
44//----------------------------------------------------------------------
45AliITSClusterFinder::AliITSClusterFinder(AliITSsegmentation *seg,
46 AliITSresponse *response,
47 TClonesArray *digits){
b0f5e3fc 48 // cluster finder
49 fSegmentation=seg;
50 fResponse=response;
51 fMap = 0;
52
53 fDigits=digits;
54 fNdigits = fDigits->GetEntriesFast();
55
56 fNRawClusters=0;
57
58 SetNperMax();
59 SetClusterSize();
60 SetDeclusterFlag();
61
62 fNPeaks=-1;
63}
9de0700b 64//----------------------------------------------------------------------
65AliITSClusterFinder::~AliITSClusterFinder(){
66 // destructor cluster finder
b0f5e3fc 67
9de0700b 68 // Zero local pointers. Other classes own these pointers.
55cd883f 69 fSegmentation = 0;
9de0700b 70 fResponse = 0;
71 fMap = 0;
72 fDigits = 0;
73 fNdigits = 0;
74 fNRawClusters = 0;
75 fNperMax = 0;
76 fDeclusterFlag= 0;
77 fClusterSize = 0;
78 fNPeaks = 0;
b0f5e3fc 79}
b0f5e3fc 80//__________________________________________________________________________
81AliITSClusterFinder::AliITSClusterFinder(const AliITSClusterFinder &source){
9de0700b 82 // Copy Constructor
83 if(&source == this) return;
84 this->fDigits = source.fDigits;
85 this->fNdigits = source.fNdigits;
86 this->fResponse = source.fResponse;
87 this->fSegmentation = source.fSegmentation;
88 this->fNRawClusters = source.fNRawClusters;
89 this->fMap = source.fMap;
90 this->fNperMax = source.fNperMax;
91 this->fDeclusterFlag = source.fDeclusterFlag;
92 this->fClusterSize = source.fClusterSize;
93 this->fNPeaks = source.fNPeaks;
94 return;
b0f5e3fc 95}
9de0700b 96//______________________________________________________________________
97AliITSClusterFinder& AliITSClusterFinder::operator=(const AliITSClusterFinder &source) {
98 // Assignment operator
99
100 if(&source == this) return *this;
101 this->fDigits = source.fDigits;
102 this->fNdigits = source.fNdigits;
103 this->fResponse = source.fResponse;
104 this->fSegmentation = source.fSegmentation;
105 this->fNRawClusters = source.fNRawClusters;
106 this->fMap = source.fMap;
107 this->fNperMax = source.fNperMax;
108 this->fDeclusterFlag = source.fDeclusterFlag;
109 this->fClusterSize = source.fClusterSize;
110 this->fNPeaks = source.fNPeaks;
111 return *this;
b0f5e3fc 112}
9de0700b 113//----------------------------------------------------------------------
114void AliITSClusterFinder::AddCluster(Int_t branch, AliITSRawCluster *c){
115 // Add a raw cluster copy to the list
b0f5e3fc 116
b0f5e3fc 117 AliITS *iTS=(AliITS*)gAlice->GetModule("ITS");
118 iTS->AddCluster(branch,c);
119 fNRawClusters++;
9355b256 120}
9de0700b 121//----------------------------------------------------------------------
122void AliITSClusterFinder::AddCluster(Int_t branch, AliITSRawCluster *c,
123 AliITSRecPoint &rp){
124 // Add a raw cluster copy to the list
9355b256 125
9355b256 126 AliITS *iTS=(AliITS*)gAlice->GetModule("ITS");
127 iTS->AddCluster(branch,c);
128 fNRawClusters++;
129 iTS->AddRecPoint(rp);
b0f5e3fc 130}
f8d9a5b8 131//______________________________________________________________________
132void AliITSClusterFinder::FindRawClusters(Int_t module){
133 // Default Cluster finder.
134 // Input:
135 // Int_t module Module number for which culster are to be found.
136 // Output:
137 // none.
138 // Return:
139 // none.
140 const Int_t kelms = 10;
141 Int_t ndigits = fDigits->GetEntriesFast();
142 TObjArray *digs = new TObjArray(ndigits);
143 TObjArray *clusts = new TObjArray(ndigits); // max # cluster
144 TObjArray *clust0=0; // A spacific cluster of digits
145 TObjArray *clust1=0; // A spacific cluster of digits
146 AliITSdigit *dig=0; // locat pointer to a digit
f824982a 147 Int_t i=0,nc=0,j[4],k,k2=0;
f8d9a5b8 148
149 // Copy all digits for this module into a local TObjArray.
150 for(i=0;i<ndigits;i++) digs->AddAt(new AliITSdigit(*((AliITSdigit*)(fDigits->At(i)))),i);
151 digs->Sort();
152 // First digit is a cluster.
153 i = 0;
154 nc = 0;
155 clusts->AddAt(new TObjArray(kelms),nc);
156 clust0 = (TObjArray*)(clusts->At(nc));
157 clust0->AddAtFree(digs->At(i)); // move owner ship from digs to clusts
158 nc++;
159 for(i=1;i<ndigits;i++){
160 if(IsNeighbor(digs,i,j)){
161 dig = (AliITSdigit*)(digs->At(j[0]));
162 // Add to existing cluster. Find which cluster this digis
163 for(k=0;k<nc;k++){
164 clust0 = ((TObjArray*)(clusts->At(k)));
165 if(clust0->IndexOf(dig)>=0) break;
166 } // end for k
167 if(k>=nc){
08d213d6 168 Fatal("FindRawClusters","Digit not found as expected");
f8d9a5b8 169 } // end if
170 if(j[1]>=0){
171 dig = (AliITSdigit*)(digs->At(j[1]));
172 // Add to existing cluster. Find which cluster this digis
173 for(k2=0;k2<nc;k2++){
174 clust1 = ((TObjArray*)(clusts->At(k2)));
175 if(clust1->IndexOf(dig)>=0) break;
176 } // end for k2
177 if(k2>=nc){
08d213d6 178 Fatal("FindRawClusters","Digit not found as expected");
f8d9a5b8 179 } // end if
180 } // end if j[1]>=0
181 // Found cluster with neighboring digits add this one to it.
182 if(clust0==clust1){ // same cluster
183 clust0->AddAtFree(digs->At(i));
184 clust0 = 0; // finished with cluster. zero for safty
185 clust1 = 0; // finished wit hcluster. zero for safty
186 }else{ // two different clusters which need to be merged.
187 clust0->AddAtFree(digs->At(i)); // Add digit to this cluster.
188 for(k=0;k<clust1->GetEntriesFast();k++){
189 // move clust1 into clust0
190 clust0->AddAtFree(clust1->At(k));//move digit to this cluster
191 clust1->AddAt(0,k); // zero this one
192 } // end for k
193 delete clust1;
194 clusts->AddAt(0,k2); // zero array of clusters element clust1
195 clust0 = 0; // finished with cluster. zero for safty
196 clust1 = 0; // finished wit hcluster. zero for safty
197 } // end if clust0==clust1
198 }else{// New cluster
199 clusts->AddAt(new TObjArray(kelms),nc);
200 clust0 = ((TObjArray*)(clusts->At(nc)));
201 clust0->AddAtFree(digs->At(i));// move owner ship from digs to clusts
202 clust0 = 0; // finished with cluster. zero for safty
203 nc++;
204 } // End if IsNeighbor
205 } // end for i
206 // There are now nc clusters in clusts. Each element of clust is an
207 // array of digits which are clustered together.
208
209 // For each cluster call detector specific CreateRecPoints
210 for(i=0;i<nc;i++) CreateRecPoints((TObjArray*)(clusts->At(i)),module);
211
212 // clean up at the end.
213 for(i=0;i<nc;i++){
214 clust0 =(TObjArray*)(clusts->At(i));
215 // Digits deleted below, so zero this TObjArray
216 for(k=0;k<clust0->GetEntriesFast();k++) clust0->AddAt(0,k);
217 delete clust0; // Delete this TObjArray
218 clusts->AddAt(0,i); // Contents deleted above, so zero it.
219 } // end for i
220 delete clusts; // Delete this TObjArray/
221 // Delete the digits then the TObjArray which containted them.
222 for(i=0;i<ndigits;i++) delete ((AliITSdigit*)(digs->At(i)));
223 delete digs;
224}
225//______________________________________________________________________
bf3f2830 226Bool_t AliITSClusterFinder::IsNeighbor(TObjArray *digs,Int_t i,Int_t n[]) const{
f8d9a5b8 227 // Locagical function which checks to see if digit i has a neighbor.
228 // If so, then it returns kTRUE and its neighbor index j.
229 // This routine checks if the digits are side by side or one before the
230 // other. Requires that the array of digits be in proper order.
231 // Returns kTRUE in the following cases.
232 // ji 0j if kdiagonal j0 0i
233 // 00 0i if kdiagonal 0i j0
234 // Inputs:
235 // TObjArray *digs Array to search for neighbors in
236 // Int_t i Index of digit for which we are searching for
237 // a neighbor of.
238 // Output:
239 // Int_t j[4] Index of one or more of the digits which is a
240 // neighbor of digit a index i.
241 // Return:
242 // Bool_t kTRUE if a neighbor was found kFALSE otherwise.
243 Int_t ix,jx,iz,jz,j;
244 const Bool_t kdiagonal=kFALSE;
245 Bool_t nei[4];
246
247 // No neighbors found if array empty.
248 if(digs->GetEntriesFast()<=0) return kFALSE;
249 // can not be a digit with first element or elements out or range
250 if(i<=0 || i>=digs->GetEntriesFast()) return kFALSE;
251
252 for(j=0;j<4;j++){n[j] = -1;nei[j]=kFALSE;}
253 ix = ((AliITSdigit*)(digs->At(i)))->GetCoord1();
254 iz = ((AliITSdigit*)(digs->At(i)))->GetCoord2();
255 for(j=0;j<i;j++){
256 jx = ((AliITSdigit*)(digs->At(j)))->GetCoord1();
257 jz = ((AliITSdigit*)(digs->At(j)))->GetCoord2();
258 if(jx+1==ix && jz ==iz){n[0] = j;nei[0] = kTRUE;}
259 if(jx ==ix && jz+1==iz){n[1] = j;nei[1] = kTRUE;}
260 if(jx+1==ix && jz+1==iz){n[2] = j;nei[2] = kTRUE;}
261 if(jx+1==ix && jz-1==iz){n[3] = j;nei[3] = kTRUE;}
262 } // end for k
263 if(nei[0]||nei[1]) return kTRUE;
264 if(kdiagonal&&(nei[2]||nei[3])) return kTRUE;
265 // no Neighbors found.
266 return kFALSE;
267}