TOF/AliTOFArray.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 /* $Id$ */
  16
  17 //
  18 // Class to hold variable size arrays of Float_t
  19 //
  20
  21 #include <TObject.h>
  22 #include <TArrayF.h>
  23 #include <TCollection.h>
  24 #include "AliTOFArray.h"
  25 //#include "AliLog.h"
  26
  27 ClassImp(AliTOFArray)
  28
  29 //-------------------------------------------------------------------
  30 AliTOFArray::AliTOFArray(Int_t size):
  31         TObject(),
  32         fSize(size),
  33         fArray(new TArrayF*[size]){
  34
  35         // constructor
  36
  37         for (Int_t i=0;i<size;i++){
  38                 fArray[i] = NULL;
  39         }
  40 }
  41 //-------------------------------------------------------------------
  42 AliTOFArray::AliTOFArray(const AliTOFArray & source):
  43         TObject(),fSize(0),fArray(0x0){
  44
  45         //
  46         // copy constructor
  47         //
  48
  49         this->fSize= source.fSize;
  50         fArray = new TArrayF*[fSize];
  51         for (Int_t ich = 0; ich<fSize; ich ++){
  52                 fArray[ich] = new TArrayF();
  53                 fArray[ich]->Set(source.fArray[ich]->GetSize());
  54                 for (Int_t j = 0; j < fArray[ich]->GetSize(); j++){
  55                         fArray[ich]->AddAt(fArray[ich]->GetAt(j),j);
  56                 }
  57         }
  58 }
  59
  60 //-------------------------------------------------------------------
  61 AliTOFArray& AliTOFArray::operator=(const AliTOFArray & source) {
  62
  63         //
  64         // assignment operator
  65         //
  66
  67         if (this != &source){
  68                 this->fSize= source.fSize;
  69                 delete [] fArray;
  70                 fArray = new TArrayF*[fSize];
  71                 for (Int_t ich = 0; ich<fSize; ich ++){
  72                         fArray[ich] = new TArrayF();
  73                         fArray[ich]->Set(source.fArray[ich]->GetSize());
  74                         for (Int_t j = 0; j < fArray[ich]->GetSize(); j++){
  75                                 fArray[ich]->AddAt(fArray[ich]->GetAt(j),j);
  76                         }
  77                 }
  78         }
  79         return *this;
  80 }
  81
  82 //------------------------------------------------------------------
  83 AliTOFArray::~AliTOFArray(){
  84
  85         //
  86         // Destructor
  87         //
  88
  89         delete [] fArray;
  90 }
  91
  92 //-------------------------------------------------------------------
  93 void AliTOFArray::SetArray(Int_t pos, Int_t size) {
  94
  95         //
  96         // adding an array of Float_t with size=size
  97         //
  98
  99         if (pos>-1 && pos < fSize){
 100                 if (!fArray[pos]) {
 101                         //                      printf("Creating array\n");
 102                         fArray[pos] = new TArrayF();
 103                 }
 104                 fArray[pos]->Reset();
 105                 fArray[pos]->Set(size);
 106         }
 107         else printf("Position out of bounds, returning\n");
 108         return;
 109 }
 110
 111 //-------------------------------------------------------------------
 112 void AliTOFArray::SetAt(Int_t pos, Int_t nelements, Float_t* content) {
 113
 114         // pos = index of the array to be modified
 115         // nelements = n. of elements to be modified in array
 116         // content = values to be set in array
 117
 118         if (pos>-1 && pos < fSize){
 119                 if (fArray[pos]){
 120                         Int_t size = fArray[pos]->GetSize();
 121                         if (nelements <= size){
 122                                 for (Int_t i=0;i<nelements;i++){
 123                                         fArray[pos]->AddAt(content[i],i);
 124                                 }
 125                         }
 126                         else printf("Too many elements to be added, returning without adding any\n");
 127                 }
 128                 else printf("Non-existing array, returning\n");
 129         }
 130         else printf("Position out of bounds, returning\n");
 131         return;
 132 }
 133
 134 //-------------------------------------------------------------------
 135 void AliTOFArray::SetAt(Int_t pos, Int_t ielement, Float_t content) {
 136
 137         // pos = index of the array to be modified
 138         // ielement = index of the element to be modified in array
 139         // content = value to be set in array
 140
 141         if (pos>-1 && pos < fSize){
 142                 if (fArray[pos]){
 143                         Int_t size = fArray[pos]->GetSize();
 144                         if (ielement < size){
 145                                 //printf("Adding %f content in position %d to array %d \n",content, ielement, pos);
 146                                 fArray[pos]->AddAt(content,ielement);
 147                         }
 148                         else if (ielement == size) {
 149                                 printf ("Increasing the size by 1 and adding a new element to the array\n");
 150                                 fArray[pos]->Set(size+1);
 151                                 fArray[pos]->AddAt(content,ielement);
 152                         }
 153                         else printf("Not possible to add element %d, size of the array too small, and this would not be the next entry!\n",ielement);
 154                 }
 155                 else printf("Non-existing array, returning\n");
 156         }
 157         else printf("Position out of bounds, returning\n");
 158         return;
 159 }
 160
 161 //-------------------------------------------------------------------
 162 void AliTOFArray::RemoveArray(Int_t pos) {
 163
 164         //
 165         // removing the array at position pos
 166         //
 167
 168         if (fArray[pos]) fArray[pos]->Reset();
 169         else printf("Not possible to remove array, array does not exist\n");
 170         return;
 171 }
 172
 173 //-------------------------------------------------------------------
 174 Float_t* AliTOFArray::GetArray(Int_t pos) {
 175
 176         //
 177         // Getting back array at position pos
 178         //
 179
 180         if  (pos>-1 && pos < fSize){
 181                 if (fArray[pos]){
 182                         return fArray[pos]->GetArray();
 183                 }
 184                 else printf("Non-existing array, returning\n");
 185         }
 186         else printf("Position out of bounds, returning\n");
 187         return 0;
 188 }
 189
 190 //-------------------------------------------------------------------
 191 Float_t AliTOFArray::GetArrayAt(Int_t pos, Int_t ielement) {
 192
 193         //
 194         // Getting back ielement of array at position pos
 195         //
 196
 197         if  (pos>-1 && pos < fSize){
 198                 if (fArray[pos]){
 199                         if (ielement<fArray[pos]->GetSize()){
 200                                 return fArray[pos]->GetAt(ielement);
 201                         }
 202                         else printf("Element in array out of bounds, returning\n");
 203                 }
 204                 else printf("Non-existing array, returning\n");
 205         }
 206         else printf("Position out of bounds, returning\n");
 207         return 0;
 208 }
 209
 210 //-------------------------------------------------------------------
 211 void AliTOFArray::ReSetArraySize(Int_t pos, Int_t size) {
 212
 213         //
 214         // Changing size of array at position pos, using TArrayF::Set method
 215         // (without loosing what is already there)
 216         //
 217
 218         if  (pos>-1 && pos < fSize){
 219                 if (fArray[pos]){
 220                         fArray[pos]->Set(size);
 221                 }
 222                 else printf("Non-existing array, returning\n");
 223         }
 224         else printf("Position out of bounds, returning\n");
 225         return;
 226 }
 227
 228 //-------------------------------------------------------------------
 229 Int_t AliTOFArray::GetArraySize(Int_t pos) {
 230
 231         //
 232         // Getting back size of array at position pos
 233         //
 234
 235         if  (pos>-1 && pos < fSize){
 236                 if (fArray[pos]){
 237                         return fArray[pos]->GetSize();
 238                 }
 239                 else printf("Non-existing array, returning\n");
 240         }
 241         else printf("Position out of bounds, returning\n");
 242         return -1;
 243 }
 244
 245 //-------------------------------------------------------------------
 246 Long64_t AliTOFArray::Merge(TCollection *list){
 247
 248         //
 249         // Merging method
 250         //
 251
 252         if (!list) return 0;
 253         if (list->IsEmpty()) return 1;
 254         printf("Merging %d AliTOFArrays %s\n", list->GetSize()+1, GetName());
 255
 256         // iterating over the entries in the TList
 257         TIter next(list);
 258         AliTOFArray *tofArray;
 259         Int_t count = 0; // object counter
 260         while ((tofArray=(AliTOFArray*)next())) {
 261                 //              printf("Count = %d \n",count);
 262                 //if (!tofArray) continue; // dead_code x coverity
 263                 if (tofArray->GetSize() != fSize){
 264                         printf("Merging with current entry in list not possible, AliTOFArray in the list has size different from the current one\n");
 265                         continue;
 266                 }
 267                 for (Int_t i = 0; i<fSize; i++){
 268                         Float_t* tempArray = tofArray->GetArray(i);
 269                         Int_t tempSize = tofArray->GetArraySize(i);
 270                         Int_t currentSize = GetArraySize(i);
 271                         Int_t mergeSize = currentSize+tempSize;
 272                         fArray[i]->Set(mergeSize);
 273                         if (tempSize !=0){
 274                                 for (Int_t j = currentSize; j<mergeSize; j++){
 275                                         SetAt(i,j,tempArray[j-currentSize]);
 276                                 }
 277                         }
 278                 }
 279                 count++;
 280                 printf("Count = %d \n",count);
 281
 282         }
 283         return count+1;
 284
 285 }
 286