[u/mrichter/AliRoot.git] / STEER / AliOADBContainer.cxx

/**************************************************************************
 * Copyright(c) 1998-2007, ALICE Experiment at CERN, All rights reserved. *
 *                                                                        *
 * Author: The ALICE Off-line Project.                                    *
 * Contributors are mentioned in the code where appropriate.              *
 *                                                                        *
 * Permission to use, copy, modify and distribute this software and its   *
 * documentation strictly for non-commercial purposes is hereby granted   *
 * without fee, provided that the above copyright notice appears in all   *
 * copies and that both the copyright notice and this permission notice   *
 * appear in the supporting documentation. The authors make no claims     *
 * about the suitability of this software for any purpose. It is          *
 * provided "as is" without express or implied warranty.                  *
 **************************************************************************/

/* $Id$ */

//-------------------------------------------------------------------------
//     Offline Analysis Database Container and Service Class 
//     Author: Andreas Morsch, CERN
//-------------------------------------------------------------------------


#include "AliOADBContainer.h"
#include "AliLog.h"
#include <TObjArray.h>
#include <TArrayI.h>
#include <TFile.h>
#include <TList.h>
#include <TBrowser.h>
#include <TSystem.h>
#include <TError.h>

ClassImp(AliOADBContainer);

//______________________________________________________________________________
AliOADBContainer::AliOADBContainer() : 
  TNamed(),
  fArray(0),
  fDefaultList(0),
  fLowerLimits(),
  fUpperLimits(),
  fEntries(0)
{
  // Default constructor
}

AliOADBContainer::AliOADBContainer(const char* name) : 
  TNamed(name, "OADBContainer"),
  fArray(new TObjArray(100)),
  fDefaultList(new TList()),
  fLowerLimits(),
  fUpperLimits(),
  fEntries(0)
{
  // Constructor
}


//______________________________________________________________________________
AliOADBContainer::~AliOADBContainer() 
{
  // destructor
}

//______________________________________________________________________________
AliOADBContainer::AliOADBContainer(const AliOADBContainer& cont) :
  TNamed(cont),
  fArray(cont.fArray),
  fDefaultList(cont.fDefaultList),
  fLowerLimits(cont.fLowerLimits),
  fUpperLimits(cont.fUpperLimits),
  fEntries(cont.fEntries)
{
  // Copy constructor.
}

//______________________________________________________________________________
AliOADBContainer& AliOADBContainer::operator=(const AliOADBContainer& cont)
{
  //
  // Assignment operator
  // Copy objects related to run ranges
  if(this!=&cont) {
    TNamed::operator=(cont);
    fEntries = cont.fEntries;
    fLowerLimits.Set(fEntries);
    fUpperLimits.Set(fEntries);
    for (Int_t i = 0; i < fEntries; i++) {
	fLowerLimits[i] = cont.fLowerLimits[i]; 
	fUpperLimits[i] = cont.fUpperLimits[i];
	fArray->AddAt(cont.fArray->At(i), i);
    }
  }
  //
  // Copy default objects
  TList* list = cont.GetDefaultList();
  TIter next(list);
  TObject* obj;
  while((obj = next())) fDefaultList->Add(obj);
  //
  return *this;
}

void AliOADBContainer::AppendObject(TObject* obj, Int_t lower, Int_t upper)
{
  //
  // Append a new object to the list 
  //
  // Check that there is no overlap with existing run ranges
  Int_t index = HasOverlap(lower, upper);
  
  if (index != -1) {
    AliFatal(Form("Ambiguos validity range (%5d, %5.5d-%5.5d) !\n", index,lower,upper));
    return;
  }
  //
  // Adjust arrays
  fEntries++;
  fLowerLimits.Set(fEntries);
  fUpperLimits.Set(fEntries);

  // Add the object
  fLowerLimits[fEntries - 1] = lower;
  fUpperLimits[fEntries - 1] = upper;
  fArray->Add(obj);
}

void AliOADBContainer::RemoveObject(Int_t idx)
{
  //
  // Remove object from the list 

  //
  // Check that index is inside range 
  if (idx < 0 || idx >= fEntries) 
    {
      AliError(Form("Index out of Range %5d >= %5d", idx, fEntries));
      return;
    }
  //
  // Remove the object
  TObject* obj = fArray->RemoveAt(idx);
  delete obj;
  //
  // Adjust the run ranges and shrink the array
  for (Int_t i = idx; i < (fEntries-1); i++) {
    fLowerLimits[i] = fLowerLimits[i + 1]; 
    fUpperLimits[i] = fUpperLimits[i + 1];
    fArray->AddAt(fArray->At(i+1), i);
  }
  fArray->RemoveAt(fEntries - 1);
  fEntries--;
}

void AliOADBContainer::UpdateObject(Int_t idx, TObject* obj, Int_t lower, Int_t upper)
{
  //
  // Update an existing object, at a given position 

  // Check that index is inside range
  if (idx < 0 || idx >= fEntries) 
    {
      AliError(Form("Index out of Range %5d >= %5d", idx, fEntries));
      return;
    }
  //
  // Remove the old object and reset the range
  //  TObject* obj2 = 
  fArray->RemoveAt(idx);
  // don't delete it: if you are updating it may be pointing to the same location of obj...
  //  delete obj2;
  fLowerLimits[idx] = -1;
  fUpperLimits[idx] = -1;
  // Check that there is no overlap with existing run ranges  
  Int_t index = HasOverlap(lower, upper);
  if (index != -1) {
    AliFatal(Form("Ambiguos validity range (%5d, %5.5d-%5.5d) !\n", index,lower,upper));
    return;
  }
  //
  // Add object at the same position
  //printf("idx %d obj %llx\n", idx, obj);
  fLowerLimits[idx] = lower;
  fUpperLimits[idx] = upper;
  fArray->AddAt(obj, idx);

}
    
 
void  AliOADBContainer::AddDefaultObject(TObject* obj)
{
  // Add a default object
  fDefaultList->Add(obj);
}

void  AliOADBContainer::CleanDefaultList()
{
  // Clean default list
  fDefaultList->Delete();
}

Int_t AliOADBContainer::GetIndexForRun(Int_t run) const
{
  //
  // Find the index for a given run 
  
  Int_t found = 0;
  Int_t index = -1;
  for (Int_t i = 0; i < fEntries; i++) 
    {
      if (run >= fLowerLimits[i] && run <= fUpperLimits[i])
	{
	  found++;
	  index = i;
	}
    }

  if (found > 1) {
    AliError(Form("More than one (%5d) object found; return last (%5d) !\n", found, index));
  } else if (index == -1) {
    AliWarning(Form("No object found for run %5d !\n", run));
  }
  
  return index;
}

TObject* AliOADBContainer::GetObject(Int_t run, const char* def) const
{
  // Return object for given run or default if not found
  TObject* obj = 0;
  Int_t idx = GetIndexForRun(run);
  if (idx == -1) {
    // no object found, try default
    obj = fDefaultList->FindObject(def);
    if (!obj) {
      AliError("Default Object not found !\n");
      return (0);
    } else {
      return (obj);
    }
  } else {
    return (fArray->At(idx));
  }
}

TObject* AliOADBContainer::GetObjectByIndex(Int_t run) const
{
  // Return object for given index
  return (fArray->At(run));
}

void AliOADBContainer::WriteToFile(const char* fname) const
{
  //
  // Write object to file
  TFile* f = new TFile(fname, "update");
  Write();
  f->Purge();
  f->Close();
}

Int_t AliOADBContainer::InitFromFile(const char* fname, const char* key)
{
    // 
    // Initialize object from file
    TFile* file = TFile::Open(fname);
    if (!file) return (1);
    AliOADBContainer* cont  = 0;
    file->GetObject(key, cont);
    if (!cont)
    {
	AliError("Object not found in file \n");	
	return 1;
    }

    SetName(cont->GetName());
    SetTitle(cont->GetTitle());

    fEntries = cont->GetNumberOfEntries();
    fLowerLimits.Set(fEntries);
    fUpperLimits.Set(fEntries);
    for (Int_t i = 0; i < fEntries; i++) {
	fLowerLimits[i] = cont->LowerLimit(i); 
	fUpperLimits[i] = cont->UpperLimit(i);
	fArray->AddAt(cont->GetObjectByIndex(i), i);
    }
    if (!fDefaultList) fDefaultList = new TList(); 
    TIter next(cont->GetDefaultList());
    TObject* obj;
    while((obj = next())) fDefaultList->Add(obj);

    return 0;
    
}


void AliOADBContainer::List()
{
  //
  // List Objects
  printf("Entries %d\n", fEntries);
  
  for (Int_t i = 0; i < fEntries; i++) {
    printf("Lower %5d Upper %5d \n", fLowerLimits[i], fUpperLimits[i]);
    (fArray->At(i))->Dump();
  }
  TIter next(fDefaultList);
  TObject* obj;
  while((obj = next())) obj->Dump();

}

Int_t AliOADBContainer::HasOverlap(Int_t lower, Int_t upper) const
{
  //
  // Checks for overlpapping validity regions
  for (Int_t i = 0; i < fEntries; i++) {
    if ((lower >= fLowerLimits[i] && lower <= fUpperLimits[i]) ||
	(upper >= fLowerLimits[i] && upper <= fUpperLimits[i]))
      {
	return (i);
      }
  }
  return (-1);
}

void AliOADBContainer::Browse(TBrowser *b)
{
   // Browse this object.
   // If b=0, there is no Browse call TObject::Browse(0) instead.
   //         This means TObject::Inspect() will be invoked indirectly


  if (b) {
    for (Int_t i = 0; i < fEntries; i++) {
      b->Add(fArray->At(i),Form("%9.9d - %9.9d", fLowerLimits[i], fUpperLimits[i]));
    }
    TIter next(fDefaultList);
    TObject* obj;
    while((obj = next())) b->Add(obj);
        
  }     
   else
      TObject::Browse(b);
}

//______________________________________________________________________________
const char* AliOADBContainer::GetOADBPath()
{
// returns the path of the OADB
// this static function just depends on environment variables

   static TString oadbPath;

   if (gSystem->Getenv("OADB_PATH"))
      oadbPath = gSystem->Getenv("OADB_PATH");
   else if (gSystem->Getenv("ALICE_ROOT"))
      oadbPath.Form("%s/OADB", gSystem->Getenv("ALICE_ROOT"));
   else
   ::Fatal("AliAnalysisManager::GetOADBPath", "Cannot figure out AODB path. Define ALICE_ROOT or OADB_PATH!");
   return oadbPath;
}
Commit	Line	Data
cc336771	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>
bad1b400	31	#include <TList.h>
60cfe266	32	#include <TBrowser.h>
	33	#include <TSystem.h>
	34	#include <TError.h>
cc336771	35
	36	ClassImp(AliOADBContainer);
	37
	38	//______________________________________________________________________________
	39	AliOADBContainer::AliOADBContainer() :
	40	TNamed(),
63671ce7	41	fArray(0),
63671ce7	42	fDefaultList(0),
cc336771	43	fLowerLimits(),
	44	fUpperLimits(),
	45	fEntries(0)
	46	{
58a28442	47	// Default constructor
cc336771	48	}
cc336771	49
0add5ddf	50	AliOADBContainer::AliOADBContainer(const char* name) :
cc336771	51	TNamed(name, "OADBContainer"),
cc336771	52	fArray(new TObjArray(100)),
bad1b400	53	fDefaultList(new TList()),
cc336771	54	fLowerLimits(),
	55	fUpperLimits(),
	56	fEntries(0)
	57	{
58a28442	58	// Constructor
cc336771	59	}
	60
	61
	62	//______________________________________________________________________________
	63	AliOADBContainer::~AliOADBContainer()
	64	{
	65	// destructor
	66	}
	67
	68	//______________________________________________________________________________
	69	AliOADBContainer::AliOADBContainer(const AliOADBContainer& cont) :
	70	TNamed(cont),
	71	fArray(cont.fArray),
bad1b400	72	fDefaultList(cont.fDefaultList),
cc336771	73	fLowerLimits(cont.fLowerLimits),
	74	fUpperLimits(cont.fUpperLimits),
	75	fEntries(cont.fEntries)
	76	{
	77	// Copy constructor.
	78	}
	79
	80	//______________________________________________________________________________
	81	AliOADBContainer& AliOADBContainer::operator=(const AliOADBContainer& cont)
	82	{
58a28442	83	//
cc336771	84	// Assignment operator
58a28442	85	// Copy objects related to run ranges
cc336771	86	if(this!=&cont) {
cc336771	87	TNamed::operator=(cont);
35f37af6	88	fEntries = cont.fEntries;
	89	fLowerLimits.Set(fEntries);
	90	fUpperLimits.Set(fEntries);
	91	for (Int_t i = 0; i < fEntries; i++) {
	92	fLowerLimits[i] = cont.fLowerLimits[i];
	93	fUpperLimits[i] = cont.fUpperLimits[i];
	94	fArray->AddAt(cont.fArray->At(i), i);
	95	}
cc336771	96	}
58a28442	97	//
	98	// Copy default objects
	99	TList* list = cont.GetDefaultList();
	100	TIter next(list);
	101	TObject* obj;
	102	while((obj = next())) fDefaultList->Add(obj);
	103	//
cc336771	104	return *this;
	105	}
	106
	107	void AliOADBContainer::AppendObject(TObject* obj, Int_t lower, Int_t upper)
	108	{
58a28442	109	//
cc336771	110	// Append a new object to the list
58a28442	111	//
	112	// Check that there is no overlap with existing run ranges
	113	Int_t index = HasOverlap(lower, upper);
	114
	115	if (index != -1) {
dcfbfe28	116	AliFatal(Form("Ambiguos validity range (%5d, %5.5d-%5.5d) !\n", index,lower,upper));
58a28442	117	return;
	118	}
	119	//
	120	// Adjust arrays
cc336771	121	fEntries++;
	122	fLowerLimits.Set(fEntries);
	123	fUpperLimits.Set(fEntries);
	124
58a28442	125	// Add the object
cc336771	126	fLowerLimits[fEntries - 1] = lower;
cc336771	127	fUpperLimits[fEntries - 1] = upper;
cc336771	128	fArray->Add(obj);
	129	}
	130
	131	void AliOADBContainer::RemoveObject(Int_t idx)
	132	{
58a28442	133	//
cc336771	134	// Remove object from the list
58a28442	135
	136	//
	137	// Check that index is inside range
cc336771	138	if (idx < 0 \|\| idx >= fEntries)
	139	{
	140	AliError(Form("Index out of Range %5d >= %5d", idx, fEntries));
	141	return;
	142	}
58a28442	143	//
58a28442	144	// Remove the object
cc336771	145	TObject* obj = fArray->RemoveAt(idx);
cc336771	146	delete obj;
58a28442	147	//
58a28442	148	// Adjust the run ranges and shrink the array
cc336771	149	for (Int_t i = idx; i < (fEntries-1); i++) {
	150	fLowerLimits[i] = fLowerLimits[i + 1];
	151	fUpperLimits[i] = fUpperLimits[i + 1];
	152	fArray->AddAt(fArray->At(i+1), i);
	153	}
	154	fArray->RemoveAt(fEntries - 1);
	155	fEntries--;
	156	}
	157
	158	void AliOADBContainer::UpdateObject(Int_t idx, TObject* obj, Int_t lower, Int_t upper)
	159	{
58a28442	160	//
0add5ddf	161	// Update an existing object, at a given position
0add5ddf	162
58a28442	163	// Check that index is inside range
cc336771	164	if (idx < 0 \|\| idx >= fEntries)
	165	{
	166	AliError(Form("Index out of Range %5d >= %5d", idx, fEntries));
	167	return;
	168	}
58a28442	169	//
0add5ddf	170	// Remove the old object and reset the range
d0f63026	171	// TObject* obj2 =
d0f63026	172	fArray->RemoveAt(idx);
e3c81f72	173	// don't delete it: if you are updating it may be pointing to the same location of obj...
0add5ddf	174	// delete obj2;
	175	fLowerLimits[idx] = -1;
	176	fUpperLimits[idx] = -1;
58a28442	177	// Check that there is no overlap with existing run ranges
	178	Int_t index = HasOverlap(lower, upper);
	179	if (index != -1) {
9939b6b6	180	AliFatal(Form("Ambiguos validity range (%5d, %5.5d-%5.5d) !\n", index,lower,upper));
58a28442	181	return;
	182	}
	183	//
0add5ddf	184	// Add object at the same position
e3c81f72	185	//printf("idx %d obj %llx\n", idx, obj);
cc336771	186	fLowerLimits[idx] = lower;
	187	fUpperLimits[idx] = upper;
	188	fArray->AddAt(obj, idx);
0add5ddf	189
cc336771	190	}
58a28442	191
58a28442	192
08b752d1	193	void AliOADBContainer::AddDefaultObject(TObject* obj)
bad1b400	194	{
	195	// Add a default object
	196	fDefaultList->Add(obj);
	197	}
	198
	199	void AliOADBContainer::CleanDefaultList()
	200	{
	201	// Clean default list
	202	fDefaultList->Delete();
	203	}
	204
35f37af6	205	Int_t AliOADBContainer::GetIndexForRun(Int_t run) const
cc336771	206	{
bad1b400	207	//
cc336771	208	// Find the index for a given run
0add5ddf	209
cc336771	210	Int_t found = 0;
	211	Int_t index = -1;
	212	for (Int_t i = 0; i < fEntries; i++)
	213	{
	214	if (run >= fLowerLimits[i] && run <= fUpperLimits[i])
	215	{
	216	found++;
	217	index = i;
	218	}
	219	}
bad1b400	220
	221	if (found > 1) {
	222	AliError(Form("More than one (%5d) object found; return last (%5d) !\n", found, index));
	223	} else if (index == -1) {
	224	AliWarning(Form("No object found for run %5d !\n", run));
	225	}
	226
cc336771	227	return index;
	228	}
	229
9939b6b6	230	TObject* AliOADBContainer::GetObject(Int_t run, const char* def) const
bad1b400	231	{
	232	// Return object for given run or default if not found
	233	TObject* obj = 0;
	234	Int_t idx = GetIndexForRun(run);
	235	if (idx == -1) {
	236	// no object found, try default
	237	obj = fDefaultList->FindObject(def);
	238	if (!obj) {
	239	AliError("Default Object not found !\n");
	240	return (0);
	241	} else {
	242	return (obj);
	243	}
	244	} else {
	245	return (fArray->At(idx));
	246	}
	247	}
	248
	249	TObject* AliOADBContainer::GetObjectByIndex(Int_t run) const
	250	{
	251	// Return object for given index
	252	return (fArray->At(run));
	253	}
	254
0add5ddf	255	void AliOADBContainer::WriteToFile(const char* fname) const
cc336771	256	{
bad1b400	257	//
cc336771	258	// Write object to file
a18817ac	259	TFile* f = new TFile(fname, "update");
cc336771	260	Write();
a18817ac	261	f->Purge();
cc336771	262	f->Close();
cc336771	263	}
bad1b400	264
0add5ddf	265	Int_t AliOADBContainer::InitFromFile(const char* fname, const char* key)
35f37af6	266	{
bad1b400	267	//
35f37af6	268	// Initialize object from file
	269	TFile* file = TFile::Open(fname);
	270	if (!file) return (1);
	271	AliOADBContainer* cont = 0;
	272	file->GetObject(key, cont);
	273	if (!cont)
	274	{
	275	AliError("Object not found in file \n");
	276	return 1;
	277	}
d40bb25d	278
	279	SetName(cont->GetName());
	280	SetTitle(cont->GetTitle());
	281
35f37af6	282	fEntries = cont->GetNumberOfEntries();
	283	fLowerLimits.Set(fEntries);
	284	fUpperLimits.Set(fEntries);
	285	for (Int_t i = 0; i < fEntries; i++) {
	286	fLowerLimits[i] = cont->LowerLimit(i);
	287	fUpperLimits[i] = cont->UpperLimit(i);
bad1b400	288	fArray->AddAt(cont->GetObjectByIndex(i), i);
35f37af6	289	}
d40bb25d	290	if (!fDefaultList) fDefaultList = new TList();
58a28442	291	TIter next(cont->GetDefaultList());
	292	TObject* obj;
	293	while((obj = next())) fDefaultList->Add(obj);
	294
35f37af6	295	return 0;
	296
	297	}
	298
cc336771	299
	300	void AliOADBContainer::List()
	301	{
bad1b400	302	//
cc336771	303	// List Objects
0add5ddf	304	printf("Entries %d\n", fEntries);
0add5ddf	305
cc336771	306	for (Int_t i = 0; i < fEntries; i++) {
	307	printf("Lower %5d Upper %5d \n", fLowerLimits[i], fUpperLimits[i]);
	308	(fArray->At(i))->Dump();
	309	}
58a28442	310	TIter next(fDefaultList);
	311	TObject* obj;
	312	while((obj = next())) obj->Dump();
	313
	314	}
	315
63671ce7	316	Int_t AliOADBContainer::HasOverlap(Int_t lower, Int_t upper) const
58a28442	317	{
	318	//
	319	// Checks for overlpapping validity regions
	320	for (Int_t i = 0; i < fEntries; i++) {
	321	if ((lower >= fLowerLimits[i] && lower <= fUpperLimits[i]) \|\|
	322	(upper >= fLowerLimits[i] && upper <= fUpperLimits[i]))
	323	{
	324	return (i);
	325	}
	326	}
	327	return (-1);
cc336771	328	}
08b752d1	329
	330	void AliOADBContainer::Browse(TBrowser *b)
	331	{
	332	// Browse this object.
	333	// If b=0, there is no Browse call TObject::Browse(0) instead.
	334	// This means TObject::Inspect() will be invoked indirectly
	335
	336
	337	if (b) {
	338	for (Int_t i = 0; i < fEntries; i++) {
	339	b->Add(fArray->At(i),Form("%9.9d - %9.9d", fLowerLimits[i], fUpperLimits[i]));
	340	}
	341	TIter next(fDefaultList);
	342	TObject* obj;
	343	while((obj = next())) b->Add(obj);
	344
	345	}
	346	else
	347	TObject::Browse(b);
	348	}
	349
60cfe266	350	//______________________________________________________________________________
	351	const char* AliOADBContainer::GetOADBPath()
	352	{
	353	// returns the path of the OADB
	354	// this static function just depends on environment variables
	355
	356	static TString oadbPath;
	357
	358	if (gSystem->Getenv("OADB_PATH"))
	359	oadbPath = gSystem->Getenv("OADB_PATH");
	360	else if (gSystem->Getenv("ALICE_ROOT"))
	361	oadbPath.Form("%s/OADB", gSystem->Getenv("ALICE_ROOT"));
	362	else
	363	::Fatal("AliAnalysisManager::GetOADBPath", "Cannot figure out AODB path. Define ALICE_ROOT or OADB_PATH!");
	364	return oadbPath;
	365	}