Optimisation
[u/mrichter/AliRoot.git] / OADB / AliOADBContainer.cxx
1 /**************************************************************************
2  * Copyright(c) 1998-2007, 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 //     Offline Analysis Database Container and Service Class 
20 //     Author: Andreas Morsch, CERN
21 //-------------------------------------------------------------------------
22
23
24
25
26 #include "AliOADBContainer.h"
27 #include "AliLog.h"
28 #include <TObjArray.h>
29 #include <TArrayI.h>
30 #include <TFile.h>
31 #include <TList.h>
32 #include "TBrowser.h"
33
34 ClassImp(AliOADBContainer);
35
36 //______________________________________________________________________________
37 AliOADBContainer::AliOADBContainer() : 
38   TNamed(),
39   fArray(0),
40   fDefaultList(0),
41   fLowerLimits(),
42   fUpperLimits(),
43   fEntries(0)
44 {
45   // Default constructor
46 }
47
48 AliOADBContainer::AliOADBContainer(char* name) : 
49   TNamed(name, "OADBContainer"),
50   fArray(new TObjArray(100)),
51   fDefaultList(new TList()),
52   fLowerLimits(),
53   fUpperLimits(),
54   fEntries(0)
55 {
56   // Constructor
57 }
58
59
60 //______________________________________________________________________________
61 AliOADBContainer::~AliOADBContainer() 
62 {
63   // destructor
64 }
65
66 //______________________________________________________________________________
67 AliOADBContainer::AliOADBContainer(const AliOADBContainer& cont) :
68   TNamed(cont),
69   fArray(cont.fArray),
70   fDefaultList(cont.fDefaultList),
71   fLowerLimits(cont.fLowerLimits),
72   fUpperLimits(cont.fUpperLimits),
73   fEntries(cont.fEntries)
74 {
75   // Copy constructor.
76 }
77
78 //______________________________________________________________________________
79 AliOADBContainer& AliOADBContainer::operator=(const AliOADBContainer& cont)
80 {
81   //
82   // Assignment operator
83   // Copy objects related to run ranges
84   if(this!=&cont) {
85     TNamed::operator=(cont);
86     fEntries = cont.fEntries;
87     fLowerLimits.Set(fEntries);
88     fUpperLimits.Set(fEntries);
89     for (Int_t i = 0; i < fEntries; i++) {
90         fLowerLimits[i] = cont.fLowerLimits[i]; 
91         fUpperLimits[i] = cont.fUpperLimits[i];
92         fArray->AddAt(cont.fArray->At(i), i);
93     }
94   }
95   //
96   // Copy default objects
97   TList* list = cont.GetDefaultList();
98   TIter next(list);
99   TObject* obj;
100   while((obj = next())) fDefaultList->Add(obj);
101   //
102   return *this;
103 }
104
105 void AliOADBContainer::AppendObject(TObject* obj, Int_t lower, Int_t upper)
106 {
107   //
108   // Append a new object to the list 
109   //
110   // Check that there is no overlap with existing run ranges
111   Int_t index = HasOverlap(lower, upper);
112   
113   if (index != -1) {
114     AliFatal(Form("Ambiguos validity range (%5d) !\n", index));
115     return;
116   }
117   //
118   // Adjust arrays
119   fEntries++;
120   fLowerLimits.Set(fEntries);
121   fUpperLimits.Set(fEntries);
122
123   // Add the object
124   fLowerLimits[fEntries - 1] = lower;
125   fUpperLimits[fEntries - 1] = upper;
126   fArray->Add(obj);
127 }
128
129 void AliOADBContainer::RemoveObject(Int_t idx)
130 {
131   //
132   // Remove object from the list 
133
134   //
135   // Check that index is inside range 
136   if (idx < 0 || idx >= fEntries) 
137     {
138       AliError(Form("Index out of Range %5d >= %5d", idx, fEntries));
139       return;
140     }
141   //
142   // Remove the object
143   TObject* obj = fArray->RemoveAt(idx);
144   delete obj;
145   //
146   // Adjust the run ranges and shrink the array
147   for (Int_t i = idx; i < (fEntries-1); i++) {
148     fLowerLimits[i] = fLowerLimits[i + 1]; 
149     fUpperLimits[i] = fUpperLimits[i + 1];
150     fArray->AddAt(fArray->At(i+1), i);
151   }
152   fArray->RemoveAt(fEntries - 1);
153   fEntries--;
154 }
155
156 void AliOADBContainer::UpdateObject(Int_t idx, TObject* obj, Int_t lower, Int_t upper)
157 {
158   //
159   // Append a new object to the list 
160   
161   // Check that index is inside range
162   if (idx < 0 || idx >= fEntries) 
163     {
164       AliError(Form("Index out of Range %5d >= %5d", idx, fEntries));
165       return;
166     }
167   //
168   // Check that there is no overlap with existing run ranges  
169   Int_t index = HasOverlap(lower, upper);
170   if (index != -1) {
171     AliFatal(Form("Ambiguos validity range (%5d) !\n", index));
172     return;
173   }
174   //
175   // Add object
176   fLowerLimits[idx] = lower;
177   fUpperLimits[idx] = upper;
178   fArray->AddAt(obj, idx);
179 }
180     
181  
182 void  AliOADBContainer::AddDefaultObject(TObject* obj)
183 {
184   // Add a default object
185   fDefaultList->Add(obj);
186 }
187
188 void  AliOADBContainer::CleanDefaultList()
189 {
190   // Clean default list
191   fDefaultList->Delete();
192 }
193
194 Int_t AliOADBContainer::GetIndexForRun(Int_t run) const
195 {
196   //
197   // Find the index for a given run 
198   Int_t found = 0;
199   Int_t index = -1;
200   for (Int_t i = 0; i < fEntries; i++) 
201     {
202       if (run >= fLowerLimits[i] && run <= fUpperLimits[i])
203         {
204           found++;
205           index = i;
206         }
207     }
208
209   if (found > 1) {
210     AliError(Form("More than one (%5d) object found; return last (%5d) !\n", found, index));
211   } else if (index == -1) {
212     AliWarning(Form("No object found for run %5d !\n", run));
213   }
214   
215   return index;
216 }
217
218 TObject* AliOADBContainer::GetObject(Int_t run, char* def) const
219 {
220   // Return object for given run or default if not found
221   TObject* obj = 0;
222   Int_t idx = GetIndexForRun(run);
223   if (idx == -1) {
224     // no object found, try default
225     obj = fDefaultList->FindObject(def);
226     if (!obj) {
227       AliError("Default Object not found !\n");
228       return (0);
229     } else {
230       return (obj);
231     }
232   } else {
233     return (fArray->At(idx));
234   }
235 }
236
237 TObject* AliOADBContainer::GetObjectByIndex(Int_t run) const
238 {
239   // Return object for given index
240   return (fArray->At(run));
241 }
242
243 void AliOADBContainer::WriteToFile(char* fname) const
244 {
245   //
246   // Write object to file
247   TFile* f = new TFile(fname, "update");
248   Write();
249   f->Purge();
250   f->Close();
251 }
252
253 Int_t AliOADBContainer::InitFromFile(char* fname, char* key)
254 {
255     // 
256     // Initialize object from file
257     TFile* file = TFile::Open(fname);
258     if (!file) return (1);
259     AliOADBContainer* cont  = 0;
260     file->GetObject(key, cont);
261     if (!cont)
262     {
263         AliError("Object not found in file \n");        
264         return 1;
265     }
266     
267     fEntries = cont->GetNumberOfEntries();
268     fLowerLimits.Set(fEntries);
269     fUpperLimits.Set(fEntries);
270     for (Int_t i = 0; i < fEntries; i++) {
271         fLowerLimits[i] = cont->LowerLimit(i); 
272         fUpperLimits[i] = cont->UpperLimit(i);
273         fArray->AddAt(cont->GetObjectByIndex(i), i);
274     }
275
276     TIter next(cont->GetDefaultList());
277     TObject* obj;
278     while((obj = next())) fDefaultList->Add(obj);
279
280     return 0;
281     
282 }
283
284
285 void AliOADBContainer::List()
286 {
287   //
288   // List Objects
289   for (Int_t i = 0; i < fEntries; i++) {
290     printf("Lower %5d Upper %5d \n", fLowerLimits[i], fUpperLimits[i]);
291     (fArray->At(i))->Dump();
292   }
293   TIter next(fDefaultList);
294   TObject* obj;
295   while((obj = next())) obj->Dump();
296
297 }
298
299 Int_t AliOADBContainer::HasOverlap(Int_t lower, Int_t upper) const
300 {
301   //
302   // Checks for overlpapping validity regions
303   for (Int_t i = 0; i < fEntries; i++) {
304     if ((lower >= fLowerLimits[i] && lower <= fUpperLimits[i]) ||
305         (upper >= fLowerLimits[i] && upper <= fUpperLimits[i]))
306       {
307         return (i);
308       }
309   }
310   return (-1);
311 }
312
313 void AliOADBContainer::Browse(TBrowser *b)
314 {
315    // Browse this object.
316    // If b=0, there is no Browse call TObject::Browse(0) instead.
317    //         This means TObject::Inspect() will be invoked indirectly
318
319
320   if (b) {
321     for (Int_t i = 0; i < fEntries; i++) {
322       b->Add(fArray->At(i),Form("%9.9d - %9.9d", fLowerLimits[i], fUpperLimits[i]));
323     }
324     TIter next(fDefaultList);
325     TObject* obj;
326     while((obj = next())) b->Add(obj);
327         
328   }     
329    else
330       TObject::Browse(b);
331 }
332