#101318: Patch for various problems in AliROOT
[u/mrichter/AliRoot.git] / 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