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, %5.5d-%5.5d) !\n", index,lower,upper));
 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