RALICE/AliObjMatrix.cxx

   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");
  42 // m->EnterObject(6,21,s);
  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");
  50 // m->EnterObject(8,13,s);
  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");
  58 // m->EnterObject(64,3,s);
  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"
  80
  81 ClassImp(AliObjMatrix) // Class implementation to enable ROOT I/O
  82
  83 AliObjMatrix::AliObjMatrix()
  84 {
  85 // Default constructor.
  86 // Note : The owner and swap mode flags will be initialised to 0.
  87 //        See the memberfunctions SetOwner() and SetSwapMode() for further
  88 //        details.
  89  fRows=0;
  90  fOwn=0;
  91  fSwap=0;
  92  fMaxrow=0;
  93  fMaxcol=0;
  94  fNobjects=0;
  95 }
  96 ///////////////////////////////////////////////////////////////////////////
  97 AliObjMatrix::~AliObjMatrix()
  98 {
  99 // Default destructor.
 100  if (fRows)
 101  {
 102   delete fRows;
 103   fRows=0;
 104  }
 105 }
 106 ///////////////////////////////////////////////////////////////////////////
 107 void AliObjMatrix::Reset()
 108 {
 109 // Reset the whole matrix structure.
 110 // Note : The values of the owner and swap mode flags will not be modified.
 111 //        To modify the ownership, use the memberfunction SetOwner().
 112 //        To modify the swap mode, use the memberfunction SetSwapMode().
 113  if (fRows)
 114  {
 115   delete fRows;
 116   fRows=0;
 117  }
 118
 119  fMaxrow=0;
 120  fMaxcol=0;
 121  fNobjects=0;
 122 }
 123 ///////////////////////////////////////////////////////////////////////////
 124 void AliObjMatrix::SetOwner(Int_t own)
 125 {
 126 // Set the owner flag (0/1) for the stored objects.
 127 // When the owner flag is set to 1, all entered objects are owned by the
 128 // matrix structure.
 129 // At invokation of this memberfunction the default argument is own=1.
 130 //
 131  fOwn=own;
 132
 133  if (!fRows) return;
 134
 135  for (Int_t irow=0; irow<fRows->GetSize(); irow++)
 136  {
 137   TObjArray* mrow=(TObjArray*)fRows->At(irow);
 138   if (mrow)
 139   {
 140    if (own)
 141    {
 142     mrow->SetOwner(kTRUE);
 143    }
 144    else
 145    {
 146     mrow->SetOwner(kFALSE);
 147    }
 148   }
 149  }
 150 }
 151 ///////////////////////////////////////////////////////////////////////////
 152 Int_t AliObjMatrix::GetOwner()
 153 {
 154 // Provide the owner flag for the stored objects.
 155  return fOwn;
 156 }
 157 ///////////////////////////////////////////////////////////////////////////
 158 void AliObjMatrix::SetSwapMode(Int_t swap)
 159 {
 160 // Set the swap mode flag (0/1) for the internal matrix storage.
 161 // In case the number of rows differs considerably from the number of columns,
 162 // it might be more efficient (w.r.t. memory usage and/or output file size)
 163 // to internally store the matrix with the rows and colums swapped.
 164 // This swapping is only related with the internal storage and as such
 165 // is completely hidden for the user.
 166 // At invokation of this memberfunction the default argument is swap=1.
 167 //
 168 // Note : The swap mode can only be set as long as no objects have
 169 //        been stored in the matrix structure (i.e. a new instance
 170 //        of AliObjMatrix or after invokation of the Reset() function).
 171 //
 172  if (!fRows)
 173  {
 174   fSwap=swap;
 175  }
 176  else
 177  {
 178   cout << " *AliObjMatrix::SetSwapMode* Matrix not empty ==> No action." << endl;
 179  }
 180 }
 181 ///////////////////////////////////////////////////////////////////////////
 182 Int_t AliObjMatrix::GetSwapMode()
 183 {
 184 // Provide the swap mode flag for this matrix.
 185  return fSwap;
 186 }
 187 ///////////////////////////////////////////////////////////////////////////
 188 void AliObjMatrix::EnterObject(Int_t row,Int_t col,TObject* obj)
 189 {
 190 // Enter an object to the matrix structure at location (row,col).
 191 // In case the location already contained an object, the existing object
 192 // will first be removed before the new object is stored.
 193 // According to the status of the copy flag (see the SetCopy() function)
 194 // the existing object will also be deleted.
 195 // Note : The first location in the matrix is indicated as (1,1).
 196  if (row<1 || col<1)
 197  {
 198   cout << " *AliObjMatrix::AddObject* Invalid argument(s) (row,col) : ("
 199        << row << "," << col << ")" << endl;
 200   return;
 201  }
 202
 203  if (row>fMaxrow) fMaxrow=row;
 204  if (col>fMaxcol) fMaxcol=col;
 205
 206  Int_t rowx=row;
 207  if (fSwap) rowx=col;
 208  Int_t colx=col;
 209  if (fSwap) colx=row;
 210
 211  if (!fRows)
 212  {
 213   fRows=new TObjArray(rowx);
 214   fRows->SetOwner();
 215  }
 216  else
 217  {
 218   if (rowx > fRows->GetSize()) fRows->Expand(rowx);
 219  }
 220
 221  TObjArray* mrow=(TObjArray*)fRows->At(rowx-1);
 222
 223  if (!mrow)
 224  {
 225   TObjArray* columns=new TObjArray(colx);
 226   if (fOwn) columns->SetOwner();
 227   fRows->AddAt(columns,rowx-1);
 228   mrow=columns;
 229  }
 230  else
 231  {
 232   if (colx > mrow->GetSize()) mrow->Expand(colx);
 233  }
 234
 235  TObject* old=(TObject*)mrow->At(colx-1);
 236  if (!old) fNobjects++;
 237  if (old && fOwn) delete old;
 238
 239  mrow->AddAt(obj,colx-1);
 240 }
 241 ///////////////////////////////////////////////////////////////////////////
 242 TObject* AliObjMatrix::GetObject(Int_t row,Int_t col)
 243 {
 244 // Provide a pointer to the object stored at the matrix location (row,col).
 245 // In case no object was stored at the indicated location or the location
 246 // would reside outside the matrix boundaries, a value 0 will be returned.
 247 // Note : The first location in the matrix is indicated as (1,1).
 248
 249  TObject* obj=0;
 250
 251  if (!fRows || row<1 || col<1) return obj;
 252
 253
 254  Int_t rowx=row;
 255  if (fSwap) rowx=col;
 256  Int_t colx=col;
 257  if (fSwap) colx=row;
 258
 259  TObjArray* mrow=0;
 260  if (rowx <= fRows->GetSize()) mrow=(TObjArray*)fRows->At(rowx-1);
 261
 262  if (!mrow) return obj;
 263
 264  if (colx <= mrow->GetSize()) obj=(TObject*)mrow->At(colx-1);
 265
 266  return obj;
 267 }
 268 ///////////////////////////////////////////////////////////////////////////
 269 Int_t AliObjMatrix::GetMaxRow()
 270 {
 271 // Provide the maximum row number index.
 272  return fMaxrow;
 273 }
 274 ///////////////////////////////////////////////////////////////////////////
 275 Int_t AliObjMatrix::GetMaxColumn()
 276 {
 277 // Provide the maximum column number index.
 278  return fMaxcol;
 279 }
 280 ///////////////////////////////////////////////////////////////////////////
 281 Int_t AliObjMatrix::GetNobjects()
 282 {
 283 // Provide the number of stored objects.
 284  return fNobjects;
 285 }
 286 ///////////////////////////////////////////////////////////////////////////