From e604d3a8fd8d4e53876aa5265f3ed4de91fc7a26 Mon Sep 17 00:00:00 2001 From: nick Date: Fri, 5 Mar 2004 10:32:14 +0000 Subject: [PATCH] 04-mar-2004 NvE Functionality of AliObjMatrix extended to provide the number of references and (row,col) indices of all the occurrences of the stored objects. Also an additional memberfunction AliObjMatrix::RemoveObject introduced to allow more flexibility in specifying objects to be removed. --- RALICE/AliObjMatrix.cxx | 289 ++++++++++++++++++++++++++++++++++++++++ RALICE/AliObjMatrix.h | 10 +- RALICE/history.txt | 4 + 3 files changed, 301 insertions(+), 2 deletions(-) diff --git a/RALICE/AliObjMatrix.cxx b/RALICE/AliObjMatrix.cxx index 86a3d58a87b..1a2ced9212d 100644 --- a/RALICE/AliObjMatrix.cxx +++ b/RALICE/AliObjMatrix.cxx @@ -289,6 +289,86 @@ void AliObjMatrix::RemoveObject(Int_t row,Int_t col) } } /////////////////////////////////////////////////////////////////////////// +void AliObjMatrix::RemoveObject(TObject* obj,Int_t row,Int_t col) +{ +// Remove an object from the matrix according to user specified selections. +// In case the object was owned by the matrix, it will be deleted. +// +// An object is only removed from the matrix if the stored reference matches +// the argument "obj". +// In case obj=0 no check on the matching of the stored reference is performed +// and the stored object is always removed in accordance with the other +// selection criteria. +// +// In case the argument "row" is specified, only the object references from +// that matrix row will be deleted. +// In case row=0 (default) no checking on the row index is performed. +// +// In case the argument "col" is specified, only the object references from +// that matrix column will be deleted. +// In case col=0 (default) no checking on the column index is performed. +// +// So, invokation of RemoveObject(obj) will remove all references to the +// object "obj" from the total matrix, whereas RemoveObject(obj,0,col) +// will remove all references to the object "obj" only from column "col". +// +// Notes : +// ------- +// The first location in the matrix is indicated as (1,1). +// +// Invokation of RemoveObject(0,row,col) is equivalent to invoking the +// memberfunction RemoveObject(row,col). +// Invoking the latter directly is slightly faster. +// +// Invokation of RemoveObject(0) is equivalent to invoking Reset(). +// Invoking the latter directly is slightly faster. +// + TArrayI rows; + TArrayI cols; + Int_t nrefs=0; + + if (row && col) + { + if (!obj) + { + RemoveObject(row,col); + } + else + { + TObject* objx=GetObject(row,col); + if (objx==obj) RemoveObject(row,col); + } + return; + } + + if (!row && !col) + { + if (!obj) + { + Reset(); + return; + } + else + { + nrefs=GetIndices(obj,rows,cols); + } + } + + if (row && !col) nrefs=GetIndices(obj,row,cols); + if (!row && col) nrefs=GetIndices(obj,rows,col); + + // Remove the selected objects based on the obtained row and column indices + Int_t irow,icol; + for (Int_t i=0; iGetSize(); i++) + { + TObjArray* columns=(TObjArray*)fRows->At(i); + if (!columns) continue; + + for (Int_t j=0; jGetSize(); j++) + { + TObject* objx=(TObject*)columns->At(j); + if (objx && (objx==obj || !obj)) + { + irow=i+1; + if (fSwap) irow=j+1; + icol=j+1; + if (fSwap) icol=i+1; + rows.AddAt(irow,jref); + cols.AddAt(icol,jref); + jref++; + } + // All references found ==> Done + if (jref==nrefs) break; + } + // All references found ==> Done + if (jref==nrefs) break; + } + return nrefs; +} +/////////////////////////////////////////////////////////////////////////// +Int_t AliObjMatrix::GetIndices(TObject* obj,Int_t row,TArrayI& cols) +{ +// Provide the column indices of all the storage locations of the +// specified object in the specified row of the matrix. +// The column indices are returned in the TArrayI array. +// The integer return argument represents the number of storage locations which +// were encountered for the specified object in the specified matrix row. +// +// If obj=0 no object selection is performed and all column indices +// of the stored references for all objects are returned. +// +// Notes : +// ------- +// As usual the convention is that row and column numbering starts at 1. +// +// This memberfunction always resets the TArrayI array at the start. +// +// This memberfunction can only be used to obtain the column indices +// of the object as stored via the EnterObject() memberfunction. +// This means that in case the user has entered a TObjArray as object +// (to increase the dimension of the resulting structure), the column +// indices of that TObjArray are obtained and NOT the indices of the +// actual objects contained in that TObjArray structure. +// + if (row<1 || row>GetMaxRow()) return 0; + + Int_t nrefs=GetNrefs(obj); + cols.Reset(); + cols.Set(nrefs); + if (!nrefs) return 0; + + Int_t irow,icol; + Int_t jref=0; + for (Int_t i=0; iGetSize(); i++) + { + TObjArray* columns=(TObjArray*)fRows->At(i); + if (!columns) continue; + + for (Int_t j=0; jGetSize(); j++) + { + TObject* objx=(TObject*)columns->At(j); + if (objx && (objx==obj || !obj)) + { + irow=i+1; + if (fSwap) irow=j+1; + icol=j+1; + if (fSwap) icol=i+1; + if (irow==row) + { + cols.AddAt(icol,jref); + jref++; + } + } + // All references found ==> Done + if (jref==nrefs) break; + } + // All references found ==> Done + if (jref==nrefs) break; + } + // Set the array size to the actual number of found occurrences + cols.Set(jref); + + return jref; +} +/////////////////////////////////////////////////////////////////////////// +Int_t AliObjMatrix::GetIndices(TObject* obj,TArrayI& rows,Int_t col) +{ +// Provide the row indices of all the storage locations of the +// specified object in the specified column of the matrix. +// The row indices are returned in the TArrayI array. +// The integer return argument represents the number of storage locations which +// were encountered for the specified object in the specified matrix column. +// +// If obj=0 no object selection is performed and all row indices +// of the stored references for all objects are returned. +// +// Notes : +// ------- +// As usual the convention is that row and column numbering starts at 1. +// +// This memberfunction always resets the TArrayI array at the start. +// +// This memberfunction can only be used to obtain the row indices +// of the object as stored via the EnterObject() memberfunction. +// This means that in case the user has entered a TObjArray as object +// (to increase the dimension of the resulting structure), the row +// indices of that TObjArray are obtained and NOT the indices of the +// actual objects contained in that TObjArray structure. +// + if (col<1 || col>GetMaxColumn()) return 0; + + Int_t nrefs=GetNrefs(obj); + rows.Reset(); + rows.Set(nrefs); + if (!nrefs) return 0; + + Int_t irow,icol; + Int_t jref=0; + for (Int_t i=0; iGetSize(); i++) + { + TObjArray* columns=(TObjArray*)fRows->At(i); + if (!columns) continue; + + for (Int_t j=0; jGetSize(); j++) + { + TObject* objx=(TObject*)columns->At(j); + if (objx && (objx==obj || !obj)) + { + irow=i+1; + if (fSwap) irow=j+1; + icol=j+1; + if (fSwap) icol=i+1; + if (icol==col) + { + rows.AddAt(irow,jref); + jref++; + } + } + // All references found ==> Done + if (jref==nrefs) break; + } + // All references found ==> Done + if (jref==nrefs) break; + } + // Set the array size to the actual number of found occurrences + rows.Set(jref); + + return jref; +} +/////////////////////////////////////////////////////////////////////////// diff --git a/RALICE/AliObjMatrix.h b/RALICE/AliObjMatrix.h index 70d1c54f6ab..dbe44729200 100644 --- a/RALICE/AliObjMatrix.h +++ b/RALICE/AliObjMatrix.h @@ -8,6 +8,7 @@ #include "TObject.h" #include "TObjArray.h" #include "TRefArray.h" +#include "TArrayI.h" class AliObjMatrix : public TObject { @@ -20,13 +21,18 @@ class AliObjMatrix : public TObject virtual void SetSwapMode(Int_t swap=1); // Set the swap mode flag for this matrix virtual Int_t GetSwapMode(); // Provide the swap mode flag for this matrix virtual void EnterObject(Int_t row,Int_t col,TObject* obj); // Enter an object into the matrix - virtual void RemoveObject(Int_t row,Int_t col); // Remove an object from the matrix + void RemoveObject(Int_t row,Int_t col); // Remove object at (row,col) from the matrix + void RemoveObject(TObject* obj,Int_t row=0,Int_t col=0); // Remove an object from the matrix virtual TObject* GetObject(Int_t row,Int_t col); // Provide an object from the matrix virtual Int_t GetMaxRow(); // Provide the maximum row number index virtual Int_t GetMaxColumn(); // Provide the maximum column number index virtual Int_t GetNobjects(); // Provide the number of stored objects virtual TObject* GetObject(Int_t j); // Provide pointer to the j-th object virtual TObjArray* GetObjects(); // Provide pointers of all stored onjects + Int_t GetNrefs(TObject* obj); // Provide # of stored references to this object + Int_t GetIndices(TObject* obj,TArrayI& rows,TArrayI& cols); // Provide all (row,col) indices of this object + Int_t GetIndices(TObject* obj,Int_t row,TArrayI& cols); // Provide column indices in a specific row + Int_t GetIndices(TObject* obj,TArrayI& rows,Int_t col); // Provide row indices in a specific column protected: TObjArray* fRows; // Pointers to the various arrays representing the matrix rows @@ -36,6 +42,6 @@ class AliObjMatrix : public TObject Int_t fMaxcol; // The maximum column number index TObjArray* fObjects; // Linear reference array for fast looping over the stored objects - ClassDef(AliObjMatrix,2) // Handling of a matrix structure of objects. + ClassDef(AliObjMatrix,3) // Handling of a matrix structure of objects. }; #endif diff --git a/RALICE/history.txt b/RALICE/history.txt index 470696d6efc..56b0fa150fa 100644 --- a/RALICE/history.txt +++ b/RALICE/history.txt @@ -486,3 +486,7 @@ for the particle names. The name returned by TPythia6::Pyname contains trailing characters due to an incorrect stripping process. AliCollider::MakeEvent was updated accordingly to make use of this new memberfunction. +04-mar-2004 NvE Functionality of AliObjMatrix extended to provide the number of references and + (row,col) indices of all the occurrences of the stored objects. + Also an additional memberfunction AliObjMatrix::RemoveObject introduced to allow more + flexibility in specifying objects to be removed. -- 2.43.0