]>
Commit | Line | Data |
---|---|---|
84bb7c66 | 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 | **************************************************************************/ | |
15 | ||
16 | // $Id$ | |
17 | ||
18 | /////////////////////////////////////////////////////////////////////////// | |
19 | // Class AliObjMatrix | |
20 | // Handling of a matrix structure of objects. | |
21 | // All objects which are derived from TObject may be entered into the matrix | |
22 | // structure. This means that also TObjArray objects can be entered, | |
23 | // which implies an increase of the dimension of the resulting structure. | |
24 | // | |
25 | // Example : | |
26 | // ========= | |
27 | // | |
28 | // AliObjMatrix* matrix=new AliObjMatrix(); | |
29 | // matrix->SetOwner(); | |
30 | // matrix->SetSwapMode(); | |
31 | // | |
32 | // Float_t pos[3]; | |
33 | // | |
34 | // AliSignal* s=0; | |
35 | // | |
36 | // s=new AliSignal(); | |
37 | // s->SetSignal(135); | |
38 | // pos[0]=-120.4 | |
39 | // pos[1]=78.25 | |
40 | // pos[3]=12.93 | |
41 | // s->SetPosition(pos,"car"); | |
c72198f1 | 42 | // matrix->EnterObject(6,21,s); |
84bb7c66 | 43 | // |
44 | // s=new AliSignal(); | |
45 | // s->SetSignal(25.84); | |
46 | // pos[0]=68.7 | |
47 | // pos[1]=-53.88 | |
48 | // pos[3]=22.69 | |
49 | // s->SetPosition(pos,"car"); | |
c72198f1 | 50 | // matrix->EnterObject(8,13,s); |
84bb7c66 | 51 | // |
52 | // s=new AliSignal(); | |
53 | // s->SetSignal(87.25); | |
54 | // pos[0]=154.8 | |
55 | // pos[1]=932.576 | |
56 | // pos[3]=-1382.754 | |
57 | // s->SetPosition(pos,"car"); | |
c72198f1 | 58 | // matrix->EnterObject(64,3,s); |
84bb7c66 | 59 | // |
60 | // Int_t nrows=matrix->GetMaxRow(); | |
61 | // Int_t ncols=matrix->GetMaxColumn(); | |
62 | // | |
63 | // cout << " Maxrow : " << nrows << " Maxcol : " << ncols | |
64 | // << " Nobjects : " << matrix->GetNobjects() << endl; | |
65 | // | |
66 | // for (Int_t i=1; i<=nrows; i++) | |
67 | // { | |
68 | // for (Int_t j=1; j<=ncols; j++) | |
69 | // { | |
70 | // s=(AliSignal*)matrix->GetObject(i,j); | |
71 | // if (s) cout << " At (" << i << "," << j << ") Signal : " << s->GetSignal() << endl; | |
72 | // } | |
73 | // } | |
74 | // | |
75 | //--- Author: Nick van Eijndhoven 23-jan-2003 Utrecht University | |
76 | //- Modified: NvE $Date$ Utrecht University | |
77 | /////////////////////////////////////////////////////////////////////////// | |
78 | ||
79 | #include "AliObjMatrix.h" | |
c72198f1 | 80 | #include "Riostream.h" |
84bb7c66 | 81 | |
82 | ClassImp(AliObjMatrix) // Class implementation to enable ROOT I/O | |
83 | ||
ea0b5b7f | 84 | AliObjMatrix::AliObjMatrix() : TNamed() |
84bb7c66 | 85 | { |
86 | // Default constructor. | |
87 | // Note : The owner and swap mode flags will be initialised to 0. | |
88 | // See the memberfunctions SetOwner() and SetSwapMode() for further | |
89 | // details. | |
90 | fRows=0; | |
91 | fOwn=0; | |
92 | fSwap=0; | |
93 | fMaxrow=0; | |
94 | fMaxcol=0; | |
c72198f1 | 95 | fObjects=0; |
84bb7c66 | 96 | } |
97 | /////////////////////////////////////////////////////////////////////////// | |
98 | AliObjMatrix::~AliObjMatrix() | |
99 | { | |
100 | // Default destructor. | |
101 | if (fRows) | |
102 | { | |
103 | delete fRows; | |
104 | fRows=0; | |
105 | } | |
c72198f1 | 106 | if (fObjects) |
107 | { | |
108 | delete fObjects; | |
109 | fObjects=0; | |
110 | } | |
84bb7c66 | 111 | } |
112 | /////////////////////////////////////////////////////////////////////////// | |
34c199de | 113 | AliObjMatrix::AliObjMatrix(const AliObjMatrix& m) : TNamed(m) |
114 | { | |
115 | // Copy constructor | |
116 | ||
117 | fRows=0; | |
118 | fMaxrow=0; | |
119 | fMaxcol=0; | |
120 | fObjects=0; | |
121 | ||
122 | fOwn=m.fOwn; | |
123 | fSwap=m.fSwap; | |
124 | ||
125 | Int_t maxrow=m.GetMaxRow(); | |
126 | Int_t maxcol=m.GetMaxColumn(); | |
127 | for (Int_t irow=1; irow<=maxrow; irow++) | |
128 | { | |
129 | for (Int_t icol=1; icol<=maxcol; icol++) | |
130 | { | |
131 | TObject* obj=m.GetObject(irow,icol); | |
132 | if (obj) | |
133 | { | |
134 | if (!fOwn) | |
135 | { | |
136 | EnterObject(irow,icol,obj); | |
137 | } | |
138 | else | |
139 | { | |
140 | EnterObject(irow,icol,obj->Clone()); | |
141 | } | |
142 | } | |
143 | } | |
144 | } | |
145 | } | |
146 | /////////////////////////////////////////////////////////////////////////// | |
84bb7c66 | 147 | void AliObjMatrix::Reset() |
148 | { | |
149 | // Reset the whole matrix structure. | |
150 | // Note : The values of the owner and swap mode flags will not be modified. | |
151 | // To modify the ownership, use the memberfunction SetOwner(). | |
152 | // To modify the swap mode, use the memberfunction SetSwapMode(). | |
153 | if (fRows) | |
154 | { | |
155 | delete fRows; | |
156 | fRows=0; | |
157 | } | |
c72198f1 | 158 | if (fObjects) |
159 | { | |
160 | delete fObjects; | |
161 | fObjects=0; | |
162 | } | |
84bb7c66 | 163 | |
164 | fMaxrow=0; | |
165 | fMaxcol=0; | |
84bb7c66 | 166 | } |
167 | /////////////////////////////////////////////////////////////////////////// | |
168 | void AliObjMatrix::SetOwner(Int_t own) | |
169 | { | |
170 | // Set the owner flag (0/1) for the stored objects. | |
171 | // When the owner flag is set to 1, all entered objects are owned by the | |
172 | // matrix structure. | |
173 | // At invokation of this memberfunction the default argument is own=1. | |
174 | // | |
175 | fOwn=own; | |
176 | ||
177 | if (!fRows) return; | |
178 | ||
179 | for (Int_t irow=0; irow<fRows->GetSize(); irow++) | |
180 | { | |
181 | TObjArray* mrow=(TObjArray*)fRows->At(irow); | |
182 | if (mrow) | |
183 | { | |
184 | if (own) | |
185 | { | |
186 | mrow->SetOwner(kTRUE); | |
187 | } | |
188 | else | |
189 | { | |
190 | mrow->SetOwner(kFALSE); | |
191 | } | |
192 | } | |
193 | } | |
194 | } | |
195 | /////////////////////////////////////////////////////////////////////////// | |
261c0caf | 196 | Int_t AliObjMatrix::GetOwner() const |
84bb7c66 | 197 | { |
198 | // Provide the owner flag for the stored objects. | |
199 | return fOwn; | |
200 | } | |
201 | /////////////////////////////////////////////////////////////////////////// | |
202 | void AliObjMatrix::SetSwapMode(Int_t swap) | |
203 | { | |
204 | // Set the swap mode flag (0/1) for the internal matrix storage. | |
205 | // In case the number of rows differs considerably from the number of columns, | |
206 | // it might be more efficient (w.r.t. memory usage and/or output file size) | |
207 | // to internally store the matrix with the rows and colums swapped. | |
208 | // This swapping is only related with the internal storage and as such | |
209 | // is completely hidden for the user. | |
210 | // At invokation of this memberfunction the default argument is swap=1. | |
211 | // | |
212 | // Note : The swap mode can only be set as long as no objects have | |
213 | // been stored in the matrix structure (i.e. a new instance | |
214 | // of AliObjMatrix or after invokation of the Reset() function). | |
215 | // | |
216 | if (!fRows) | |
217 | { | |
218 | fSwap=swap; | |
219 | } | |
220 | else | |
221 | { | |
222 | cout << " *AliObjMatrix::SetSwapMode* Matrix not empty ==> No action." << endl; | |
223 | } | |
224 | } | |
225 | /////////////////////////////////////////////////////////////////////////// | |
261c0caf | 226 | Int_t AliObjMatrix::GetSwapMode() const |
84bb7c66 | 227 | { |
228 | // Provide the swap mode flag for this matrix. | |
229 | return fSwap; | |
230 | } | |
231 | /////////////////////////////////////////////////////////////////////////// | |
232 | void AliObjMatrix::EnterObject(Int_t row,Int_t col,TObject* obj) | |
233 | { | |
234 | // Enter an object to the matrix structure at location (row,col). | |
235 | // In case the location already contained an object, the existing object | |
236 | // will first be removed before the new object is stored. | |
c72198f1 | 237 | // According to the status of the owner flag (see the SetOwner() function) |
84bb7c66 | 238 | // the existing object will also be deleted. |
239 | // Note : The first location in the matrix is indicated as (1,1). | |
240 | if (row<1 || col<1) | |
241 | { | |
242 | cout << " *AliObjMatrix::AddObject* Invalid argument(s) (row,col) : (" | |
243 | << row << "," << col << ")" << endl; | |
244 | return; | |
245 | } | |
246 | ||
247 | if (row>fMaxrow) fMaxrow=row; | |
248 | if (col>fMaxcol) fMaxcol=col; | |
249 | ||
250 | Int_t rowx=row; | |
251 | if (fSwap) rowx=col; | |
252 | Int_t colx=col; | |
253 | if (fSwap) colx=row; | |
254 | ||
255 | if (!fRows) | |
256 | { | |
257 | fRows=new TObjArray(rowx); | |
258 | fRows->SetOwner(); | |
259 | } | |
260 | else | |
261 | { | |
262 | if (rowx > fRows->GetSize()) fRows->Expand(rowx); | |
263 | } | |
264 | ||
265 | TObjArray* mrow=(TObjArray*)fRows->At(rowx-1); | |
266 | ||
267 | if (!mrow) | |
268 | { | |
269 | TObjArray* columns=new TObjArray(colx); | |
270 | if (fOwn) columns->SetOwner(); | |
271 | fRows->AddAt(columns,rowx-1); | |
272 | mrow=columns; | |
273 | } | |
274 | else | |
275 | { | |
276 | if (colx > mrow->GetSize()) mrow->Expand(colx); | |
277 | } | |
278 | ||
279 | TObject* old=(TObject*)mrow->At(colx-1); | |
c72198f1 | 280 | if (old) |
281 | { | |
282 | fObjects->Remove(old); | |
283 | fObjects->Compress(); | |
284 | if (fOwn) delete old; | |
285 | } | |
84bb7c66 | 286 | |
287 | mrow->AddAt(obj,colx-1); | |
c72198f1 | 288 | |
289 | if (!fObjects) fObjects=new TObjArray(); | |
290 | fObjects->Add(obj); | |
291 | } | |
292 | /////////////////////////////////////////////////////////////////////////// | |
293 | void AliObjMatrix::RemoveObject(Int_t row,Int_t col) | |
294 | { | |
295 | // Remove the object stored at the matrix location (row,col). | |
296 | // In case the object was owned by the matrix, it will be deleted. | |
297 | // | |
298 | // Note : The first location in the matrix is indicated as (1,1). | |
299 | ||
300 | TObject* obj=0; | |
301 | ||
302 | if (!fRows || row<1 || col<1) return; | |
303 | ||
304 | ||
305 | Int_t rowx=row; | |
306 | if (fSwap) rowx=col; | |
307 | Int_t colx=col; | |
308 | if (fSwap) colx=row; | |
309 | ||
310 | TObjArray* mrow=0; | |
311 | if (rowx <= fRows->GetSize()) mrow=(TObjArray*)fRows->At(rowx-1); | |
312 | ||
313 | if (!mrow) return; | |
314 | ||
315 | if (colx <= mrow->GetSize()) obj=(TObject*)mrow->At(colx-1); | |
316 | ||
317 | if (obj) | |
318 | { | |
319 | fObjects->Remove(obj); | |
320 | fObjects->Compress(); | |
321 | mrow->Remove(obj); | |
322 | if (fOwn) delete obj; | |
323 | } | |
84bb7c66 | 324 | } |
325 | /////////////////////////////////////////////////////////////////////////// | |
d0a8ef71 | 326 | void AliObjMatrix::RemoveObjects(TObject* obj,Int_t row,Int_t col) |
e604d3a8 | 327 | { |
d0a8ef71 | 328 | // Remove object(s) from the matrix according to user specified selections. |
e604d3a8 | 329 | // In case the object was owned by the matrix, it will be deleted. |
330 | // | |
331 | // An object is only removed from the matrix if the stored reference matches | |
332 | // the argument "obj". | |
333 | // In case obj=0 no check on the matching of the stored reference is performed | |
334 | // and the stored object is always removed in accordance with the other | |
335 | // selection criteria. | |
336 | // | |
337 | // In case the argument "row" is specified, only the object references from | |
338 | // that matrix row will be deleted. | |
339 | // In case row=0 (default) no checking on the row index is performed. | |
340 | // | |
341 | // In case the argument "col" is specified, only the object references from | |
342 | // that matrix column will be deleted. | |
343 | // In case col=0 (default) no checking on the column index is performed. | |
344 | // | |
d0a8ef71 | 345 | // So, invokation of RemoveObjects(obj) will remove all references to the |
346 | // object "obj" from the total matrix, whereas RemoveObjects(obj,0,col) | |
e604d3a8 | 347 | // will remove all references to the object "obj" only from column "col". |
348 | // | |
349 | // Notes : | |
350 | // ------- | |
351 | // The first location in the matrix is indicated as (1,1). | |
352 | // | |
d0a8ef71 | 353 | // Invokation of RemoveObjects(0,row,col) is equivalent to invoking the |
e604d3a8 | 354 | // memberfunction RemoveObject(row,col). |
355 | // Invoking the latter directly is slightly faster. | |
356 | // | |
d0a8ef71 | 357 | // Invokation of RemoveObjects(0) is equivalent to invoking Reset(). |
e604d3a8 | 358 | // Invoking the latter directly is slightly faster. |
359 | // | |
360 | TArrayI rows; | |
361 | TArrayI cols; | |
362 | Int_t nrefs=0; | |
363 | ||
364 | if (row && col) | |
365 | { | |
366 | if (!obj) | |
367 | { | |
368 | RemoveObject(row,col); | |
369 | } | |
370 | else | |
371 | { | |
372 | TObject* objx=GetObject(row,col); | |
373 | if (objx==obj) RemoveObject(row,col); | |
374 | } | |
375 | return; | |
376 | } | |
377 | ||
378 | if (!row && !col) | |
379 | { | |
380 | if (!obj) | |
381 | { | |
382 | Reset(); | |
383 | return; | |
384 | } | |
385 | else | |
386 | { | |
387 | nrefs=GetIndices(obj,rows,cols); | |
388 | } | |
389 | } | |
390 | ||
391 | if (row && !col) nrefs=GetIndices(obj,row,cols); | |
392 | if (!row && col) nrefs=GetIndices(obj,rows,col); | |
393 | ||
394 | // Remove the selected objects based on the obtained row and column indices | |
395 | Int_t irow,icol; | |
396 | for (Int_t i=0; i<nrefs; i++) | |
397 | { | |
398 | irow=row; | |
399 | if (!irow) irow=rows.At(i); | |
400 | icol=col; | |
401 | if (!icol) icol=cols.At(i); | |
402 | RemoveObject(irow,icol); | |
403 | } | |
404 | } | |
405 | /////////////////////////////////////////////////////////////////////////// | |
261c0caf | 406 | TObject* AliObjMatrix::GetObject(Int_t row,Int_t col) const |
84bb7c66 | 407 | { |
408 | // Provide a pointer to the object stored at the matrix location (row,col). | |
409 | // In case no object was stored at the indicated location or the location | |
410 | // would reside outside the matrix boundaries, a value 0 will be returned. | |
411 | // Note : The first location in the matrix is indicated as (1,1). | |
412 | ||
413 | TObject* obj=0; | |
414 | ||
415 | if (!fRows || row<1 || col<1) return obj; | |
416 | ||
417 | ||
418 | Int_t rowx=row; | |
419 | if (fSwap) rowx=col; | |
420 | Int_t colx=col; | |
421 | if (fSwap) colx=row; | |
422 | ||
423 | TObjArray* mrow=0; | |
424 | if (rowx <= fRows->GetSize()) mrow=(TObjArray*)fRows->At(rowx-1); | |
425 | ||
426 | if (!mrow) return obj; | |
427 | ||
428 | if (colx <= mrow->GetSize()) obj=(TObject*)mrow->At(colx-1); | |
429 | ||
430 | return obj; | |
431 | } | |
432 | /////////////////////////////////////////////////////////////////////////// | |
261c0caf | 433 | TObject* AliObjMatrix::GetObject(Int_t j) const |
c72198f1 | 434 | { |
435 | // Provide a pointer to the j-th stored object. | |
436 | // In case the index j is invalid, a value 0 will be returned. | |
437 | // The first stored object is indicated as j=1. | |
438 | // | |
439 | // Note : Do NOT delete the object. | |
d0a8ef71 | 440 | // To remove an object, the memberfunction RemoveObject() or |
441 | // RemoveObjects() should be used. | |
c72198f1 | 442 | |
443 | TObject* obj=0; | |
444 | Int_t nobj=0; | |
445 | if (fObjects) nobj=fObjects->GetSize(); | |
446 | ||
447 | if (j>0 && j<=nobj) obj=(TObject*)fObjects->At(j-1); | |
448 | ||
449 | return obj; | |
450 | } | |
451 | /////////////////////////////////////////////////////////////////////////// | |
452 | TObjArray* AliObjMatrix::GetObjects() | |
453 | { | |
454 | // Provide references to all the stored objects. | |
455 | // In case no objects are present, a value 0 will be returned. | |
456 | // | |
457 | // Note : Do NOT make any changes to the reference array apart from | |
458 | // changing the order of the pointers of the various objects. | |
459 | // For addition or removal of objects, the memberfunctions | |
d0a8ef71 | 460 | // EnterObject(), RemoveObject() or RemoveObjects() should be used. |
c72198f1 | 461 | |
462 | return fObjects; | |
463 | } | |
464 | /////////////////////////////////////////////////////////////////////////// | |
261c0caf | 465 | Int_t AliObjMatrix::GetMaxRow() const |
84bb7c66 | 466 | { |
467 | // Provide the maximum row number index. | |
468 | return fMaxrow; | |
469 | } | |
470 | /////////////////////////////////////////////////////////////////////////// | |
261c0caf | 471 | Int_t AliObjMatrix::GetMaxColumn() const |
84bb7c66 | 472 | { |
473 | // Provide the maximum column number index. | |
474 | return fMaxcol; | |
475 | } | |
476 | /////////////////////////////////////////////////////////////////////////// | |
261c0caf | 477 | Int_t AliObjMatrix::GetNobjects() const |
84bb7c66 | 478 | { |
479 | // Provide the number of stored objects. | |
c72198f1 | 480 | Int_t nobj=0; |
481 | if (fObjects) nobj=fObjects->GetEntries(); | |
482 | ||
483 | return nobj; | |
84bb7c66 | 484 | } |
485 | /////////////////////////////////////////////////////////////////////////// | |
261c0caf | 486 | Int_t AliObjMatrix::GetNrefs(TObject* obj) const |
e604d3a8 | 487 | { |
488 | // Provide the number of stored references to the specified object. | |
489 | // If obj=0 the total number of stored references for all objects is returned. | |
490 | Int_t nobjs=GetNobjects(); | |
491 | ||
492 | if (!obj) return nobjs; | |
493 | ||
494 | Int_t nrefs=0; | |
495 | for (Int_t i=1; i<=nobjs; i++) | |
496 | { | |
497 | TObject* objx=GetObject(i); | |
498 | if (objx==obj) nrefs++; | |
499 | } | |
500 | return nrefs; | |
501 | } | |
502 | /////////////////////////////////////////////////////////////////////////// | |
261c0caf | 503 | Int_t AliObjMatrix::GetIndices(TObject* obj,TArrayI& rows,TArrayI& cols) const |
e604d3a8 | 504 | { |
505 | // Provide the (row,col) indices of all the storage locations of the | |
506 | // specified object. | |
507 | // The row and column indices are returned in the two separate TArrayI arrays | |
508 | // from which the (row,col) pairs can be obtained from the corresponding | |
509 | // array indices like (row,col)=(rows.At(j),cols.At(j)). | |
510 | // The integer return argument represents the number of (row,col) pairs which | |
511 | // were encountered for the specified object. | |
512 | // | |
513 | // If obj=0 no object selection is performed and all (row,col) indices | |
514 | // of the stored references for all objects are returned. | |
515 | // | |
516 | // Notes : | |
517 | // ------- | |
518 | // As usual the convention is that row and column numbering starts at 1. | |
519 | // | |
520 | // This memberfunction always resets the two TArrayI arrays at the start. | |
521 | // | |
522 | // This memberfunction can only be used to obtain the (row,col) indices | |
523 | // of the object as stored via the EnterObject() memberfunction. | |
524 | // This means that in case the user has entered a TObjArray as object | |
525 | // (to increase the dimension of the resulting structure), the (row,col) | |
526 | // indices of that TObjArray are obtained and NOT the indices of the | |
527 | // actual objects contained in that TObjArray structure. | |
528 | // | |
529 | Int_t nrefs=GetNrefs(obj); | |
530 | rows.Reset(); | |
531 | cols.Reset(); | |
532 | rows.Set(nrefs); | |
533 | cols.Set(nrefs); | |
534 | if (!nrefs) return 0; | |
535 | ||
536 | Int_t irow,icol; | |
537 | Int_t jref=0; | |
538 | for (Int_t i=0; i<fRows->GetSize(); i++) | |
539 | { | |
540 | TObjArray* columns=(TObjArray*)fRows->At(i); | |
541 | if (!columns) continue; | |
542 | ||
543 | for (Int_t j=0; j<columns->GetSize(); j++) | |
544 | { | |
545 | TObject* objx=(TObject*)columns->At(j); | |
546 | if (objx && (objx==obj || !obj)) | |
547 | { | |
548 | irow=i+1; | |
549 | if (fSwap) irow=j+1; | |
550 | icol=j+1; | |
551 | if (fSwap) icol=i+1; | |
552 | rows.AddAt(irow,jref); | |
553 | cols.AddAt(icol,jref); | |
554 | jref++; | |
555 | } | |
556 | // All references found ==> Done | |
557 | if (jref==nrefs) break; | |
558 | } | |
559 | // All references found ==> Done | |
560 | if (jref==nrefs) break; | |
561 | } | |
562 | return nrefs; | |
563 | } | |
564 | /////////////////////////////////////////////////////////////////////////// | |
261c0caf | 565 | Int_t AliObjMatrix::GetIndices(TObject* obj,Int_t row,TArrayI& cols) const |
e604d3a8 | 566 | { |
567 | // Provide the column indices of all the storage locations of the | |
568 | // specified object in the specified row of the matrix. | |
569 | // The column indices are returned in the TArrayI array. | |
570 | // The integer return argument represents the number of storage locations which | |
571 | // were encountered for the specified object in the specified matrix row. | |
572 | // | |
573 | // If obj=0 no object selection is performed and all column indices | |
d0a8ef71 | 574 | // of the stored references for all objects in this specified matrix row |
575 | // are returned. | |
576 | // | |
577 | // If row=0 all rows will be scanned and all column indices matching the | |
578 | // object selection are returned. | |
579 | // Note that in this case multiple appearances of the same column index | |
580 | // will only be recorded once in the returned TArrayI array. | |
e604d3a8 | 581 | // |
582 | // Notes : | |
583 | // ------- | |
584 | // As usual the convention is that row and column numbering starts at 1. | |
585 | // | |
586 | // This memberfunction always resets the TArrayI array at the start. | |
587 | // | |
588 | // This memberfunction can only be used to obtain the column indices | |
589 | // of the object as stored via the EnterObject() memberfunction. | |
590 | // This means that in case the user has entered a TObjArray as object | |
591 | // (to increase the dimension of the resulting structure), the column | |
592 | // indices of that TObjArray are obtained and NOT the indices of the | |
593 | // actual objects contained in that TObjArray structure. | |
594 | // | |
d0a8ef71 | 595 | cols.Reset(); |
596 | ||
597 | if (row<0 || row>GetMaxRow()) return 0; | |
e604d3a8 | 598 | |
599 | Int_t nrefs=GetNrefs(obj); | |
e604d3a8 | 600 | cols.Set(nrefs); |
601 | if (!nrefs) return 0; | |
602 | ||
603 | Int_t irow,icol; | |
604 | Int_t jref=0; | |
d0a8ef71 | 605 | |
606 | // No specific row selection | |
607 | if (!row) | |
608 | { | |
609 | TArrayI ar; | |
610 | TArrayI ac; | |
611 | Int_t n=GetIndices(obj,ar,ac); | |
612 | Int_t found=0; | |
613 | for (Int_t idx=0; idx<n; idx++) | |
614 | { | |
615 | icol=ac.At(idx); | |
616 | found=0; | |
617 | for (Int_t k=0; k<jref; k++) | |
618 | { | |
619 | if (icol==cols.At(k)) found=1; | |
620 | } | |
621 | if (!found) | |
622 | { | |
623 | cols.AddAt(icol,jref); | |
624 | jref++; | |
625 | } | |
626 | } | |
627 | // Set the array size to the actual number of different column indices | |
628 | cols.Set(jref); | |
629 | ||
630 | return jref; | |
631 | } | |
632 | ||
633 | // Specific row selection | |
e604d3a8 | 634 | for (Int_t i=0; i<fRows->GetSize(); i++) |
635 | { | |
636 | TObjArray* columns=(TObjArray*)fRows->At(i); | |
637 | if (!columns) continue; | |
638 | ||
639 | for (Int_t j=0; j<columns->GetSize(); j++) | |
640 | { | |
641 | TObject* objx=(TObject*)columns->At(j); | |
642 | if (objx && (objx==obj || !obj)) | |
643 | { | |
644 | irow=i+1; | |
645 | if (fSwap) irow=j+1; | |
646 | icol=j+1; | |
647 | if (fSwap) icol=i+1; | |
648 | if (irow==row) | |
649 | { | |
650 | cols.AddAt(icol,jref); | |
651 | jref++; | |
652 | } | |
653 | } | |
654 | // All references found ==> Done | |
655 | if (jref==nrefs) break; | |
656 | } | |
657 | // All references found ==> Done | |
658 | if (jref==nrefs) break; | |
659 | } | |
660 | // Set the array size to the actual number of found occurrences | |
661 | cols.Set(jref); | |
662 | ||
663 | return jref; | |
664 | } | |
665 | /////////////////////////////////////////////////////////////////////////// | |
261c0caf | 666 | Int_t AliObjMatrix::GetIndices(TObject* obj,TArrayI& rows,Int_t col) const |
e604d3a8 | 667 | { |
668 | // Provide the row indices of all the storage locations of the | |
669 | // specified object in the specified column of the matrix. | |
670 | // The row indices are returned in the TArrayI array. | |
671 | // The integer return argument represents the number of storage locations which | |
672 | // were encountered for the specified object in the specified matrix column. | |
673 | // | |
674 | // If obj=0 no object selection is performed and all row indices | |
d0a8ef71 | 675 | // of the stored references for all objects in this specified matrix column |
676 | // are returned. | |
677 | // | |
678 | // If col=0 all columns will be scanned and all row indices matching the | |
679 | // object selection are returned. | |
680 | // Note that in this case multiple appearances of the same row index | |
681 | // will only be recorded once in the returned TArrayI array. | |
e604d3a8 | 682 | // |
683 | // Notes : | |
684 | // ------- | |
685 | // As usual the convention is that row and column numbering starts at 1. | |
686 | // | |
687 | // This memberfunction always resets the TArrayI array at the start. | |
688 | // | |
689 | // This memberfunction can only be used to obtain the row indices | |
690 | // of the object as stored via the EnterObject() memberfunction. | |
691 | // This means that in case the user has entered a TObjArray as object | |
692 | // (to increase the dimension of the resulting structure), the row | |
693 | // indices of that TObjArray are obtained and NOT the indices of the | |
694 | // actual objects contained in that TObjArray structure. | |
695 | // | |
d0a8ef71 | 696 | rows.Reset(); |
697 | ||
698 | if (col<0 || col>GetMaxColumn()) return 0; | |
e604d3a8 | 699 | |
700 | Int_t nrefs=GetNrefs(obj); | |
e604d3a8 | 701 | rows.Set(nrefs); |
702 | if (!nrefs) return 0; | |
703 | ||
704 | Int_t irow,icol; | |
705 | Int_t jref=0; | |
d0a8ef71 | 706 | |
707 | // No specific column selection | |
708 | if (!col) | |
709 | { | |
710 | TArrayI ar; | |
711 | TArrayI ac; | |
712 | Int_t n=GetIndices(obj,ar,ac); | |
713 | Int_t found=0; | |
714 | for (Int_t idx=0; idx<n; idx++) | |
715 | { | |
716 | irow=ar.At(idx); | |
717 | found=0; | |
718 | for (Int_t k=0; k<jref; k++) | |
719 | { | |
720 | if (irow==rows.At(k)) found=1; | |
721 | } | |
722 | if (!found) | |
723 | { | |
724 | rows.AddAt(irow,jref); | |
725 | jref++; | |
726 | } | |
727 | } | |
728 | // Set the array size to the actual number of different row indices | |
729 | rows.Set(jref); | |
730 | ||
731 | return jref; | |
732 | } | |
733 | ||
734 | // Specific column selection | |
e604d3a8 | 735 | for (Int_t i=0; i<fRows->GetSize(); i++) |
736 | { | |
737 | TObjArray* columns=(TObjArray*)fRows->At(i); | |
738 | if (!columns) continue; | |
739 | ||
740 | for (Int_t j=0; j<columns->GetSize(); j++) | |
741 | { | |
742 | TObject* objx=(TObject*)columns->At(j); | |
743 | if (objx && (objx==obj || !obj)) | |
744 | { | |
745 | irow=i+1; | |
746 | if (fSwap) irow=j+1; | |
747 | icol=j+1; | |
748 | if (fSwap) icol=i+1; | |
749 | if (icol==col) | |
750 | { | |
751 | rows.AddAt(irow,jref); | |
752 | jref++; | |
753 | } | |
754 | } | |
755 | // All references found ==> Done | |
756 | if (jref==nrefs) break; | |
757 | } | |
758 | // All references found ==> Done | |
759 | if (jref==nrefs) break; | |
760 | } | |
761 | // Set the array size to the actual number of found occurrences | |
762 | rows.Set(jref); | |
763 | ||
764 | return jref; | |
765 | } | |
766 | /////////////////////////////////////////////////////////////////////////// | |
34c199de | 767 | TObject* AliObjMatrix::Clone(const char* name) const |
768 | { | |
769 | // Make a deep copy of the current object and provide the pointer to the copy. | |
770 | // This memberfunction enables automatic creation of new objects of the | |
771 | // correct type depending on the object type, a feature which may be very useful | |
772 | // for containers when adding objects in case the container owns the objects. | |
773 | ||
774 | AliObjMatrix* m=new AliObjMatrix(*this); | |
775 | if (name) | |
776 | { | |
777 | if (strlen(name)) m->SetName(name); | |
778 | } | |
779 | return m; | |
780 | } | |
781 | /////////////////////////////////////////////////////////////////////////// |