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