[u/mrichter/AliRoot.git] / TRD / AliTRDsegmentArrayBase.cxx

/**************************************************************************
 * Copyright(c) 1998-1999, 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.                  *
 **************************************************************************/

/*
$Log$
Revision 1.1.4.1  2000/05/08 14:55:03  cblume
Bug fixes

Revision 1.1  2000/02/28 19:02:56  cblume
Add new TRD classes

*/

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
//  Alice segment manager object                                             //
//                                                                           //
//  AliTRDsegmentIDArray object  is array of pointers to object derived from //
//  AliTRDsegmentID object                                                   //
//  AliTRDsegmentID - object in comparison with TObject enhalt               //
//  additional information fSegmentID                                        //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

#include  <TROOT.h>
#include <TTree.h>
#include "TClonesArray.h"
#include "TDirectory.h"
#include "AliTRDarrayI.h"
#include "TError.h"
#include "TClass.h"

#include "AliTRDsegmentID.h"
#include "AliTRDsegmentArrayBase.h"

ClassImp(AliTRDsegmentArrayBase)
  
//_____________________________________________________________________________
AliTRDsegmentArrayBase::AliTRDsegmentArrayBase()
{
  //
  //
  //

  fNSegment  = 0;
  fSegment   = 0; 
  fTreeIndex = 0;
  fTree      = 0;
  fClass     = 0;

}

//_____________________________________________________________________________
AliTRDsegmentArrayBase::AliTRDsegmentArrayBase(Text_t *classname, Int_t n)
{
  //
  //constructor which 
  // 
  //  Create an array of objects of classname. The class must inherit from
  //  AliTRDsegmentID .  The second argument adjust number of entries in 
  //  the array.
  fNSegment=0;
  fSegment =0; 
  fTreeIndex = 0;
  fTree  = 0;
  fClass = 0;
  SetClass(classname);
  if (MakeArray(n)==kFALSE){
     Error("AliTRDsegmentArrayBase", "can't allocate %d segments in memory",n);
     return;
   }
}

//_____________________________________________________________________________
Bool_t AliTRDsegmentArrayBase:: SetClass(Text_t *classname)
{
  //
  //set class of stored object
  if ( fClass !=0 ) {
    delete fClass;
    fClass = 0;
  }
  if (fTree !=0) {
    delete fTree;
    fTree = 0;
    fBranch = 0;
    delete fTreeIndex;
    fTreeIndex = 0;
  } 
  if (fSegment != 0) {
    fSegment->Delete();
    delete fSegment;
    fSegment = 0;
  }
  if (!gROOT)
      ::Fatal("AliTRDsegmentArrayBase::AliTRDsegmentArrayBase", "ROOT system not initialized");
   
   fClass = gROOT->GetClass(classname);
   if (!fClass) {
      Error("AliTRDsegmentArrayBase", "%s is not a valid class name", classname);
      return kFALSE;
   }
   if (!fClass->InheritsFrom(AliTRDsegmentID::Class())) {
      Error("AliTRDsegmentArrayBase", "%s does not inherit from AliTRDsegmentID", classname);
      return kFALSE;
   }  
   return kTRUE;
}

//_____________________________________________________________________________
//Bool_t AliTRDsegmentArrayBase::ClassError( )
//{
  //signalize class error 
  //  if (!fClass) {
  //    Error("AliTRDsegmentArrayBase", "%s is not a valid class name", classname);
  //    return kFALSE;
  // }
////  return kFALSE;
//}

//_____________________________________________________________________________
AliTRDsegmentArrayBase::~AliTRDsegmentArrayBase()
{
  if (fNSegment>0){
    fSegment->Delete();
    delete fSegment;
  }
  if (fTree) delete fTree;
  if (fTreeIndex) delete fTreeIndex;
  if (fClass!=0) delete fClass;
}

//_____________________________________________________________________________
AliTRDsegmentID * AliTRDsegmentArrayBase::NewSegment()
{
  //
  //create object according class information
  if (fClass==0) return 0;
  AliTRDsegmentID * segment = (AliTRDsegmentID * )fClass->New();
  if (segment == 0) return 0;
  return segment;
}

//_____________________________________________________________________________
Bool_t AliTRDsegmentArrayBase::AddSegment(AliTRDsegmentID *segment)
{
  //
  // add segment to array
  //
  if (segment==0) return kFALSE;
  if (fSegment==0) return kFALSE;
  if (fClass==0) return kFALSE;
  if (!(segment->IsA()->InheritsFrom(fClass))){
    Error("AliTRDsegmentArrayBase", "added class %s  is not of proper type ",
	  segment->IsA()->GetName());
      return kFALSE;
  }
  fSegment->AddAt(segment,segment->GetID());
  fNSegment = fSegment->GetLast()+1;
  return kTRUE;
}

//_____________________________________________________________________________
AliTRDsegmentID * AliTRDsegmentArrayBase::AddSegment(Int_t index)
{
  //
  // add segment to array
  //
  if (fSegment==0) return 0;
  if (fClass==0) return 0;
  //  AliTRDsegmentID * segment = (AliTRDsegmentID * )fClass->New();
  AliTRDsegmentID * segment = NewSegment();
  if (segment == 0) return 0;
  fSegment->AddAt(segment,index);
  segment->SetID(index);
  fNSegment = fSegment->GetLast()+1;
  return segment;
}

//_____________________________________________________________________________
Bool_t AliTRDsegmentArrayBase::MakeArray(Int_t n)
{
  //
  //make array of pointers to Segments
  //
  if (fSegment) {
    fSegment->Delete();
    delete fSegment;
  }
  if (fTreeIndex) delete   fTreeIndex;  
  fSegment = new TObjArray(n);
  fTreeIndex = new AliTRDarrayI;
  fTreeIndex->Set(n);
  fNSegment=n;
  if ( (fSegment) && (fTreeIndex)) return kTRUE;
  else return kFALSE;		  
}

//_____________________________________________________________________________
void AliTRDsegmentArrayBase::ClearSegment(Int_t index)
{
  //
  //remove segment from active memory    
  //
  if ((*fSegment)[index]){
    //    (*fSegment)[index]->Delete(); //not working for TClonesArray
    delete (*fSegment)[index]; //because problem with deleting TClonesArray
    fSegment->RemoveAt(index);
  }
}

//_____________________________________________________________________________
void AliTRDsegmentArrayBase::MakeTree()
{
  //  AliTRDsegmentID  segment;
  AliTRDsegmentID * psegment = NewSegment();  
  if (fTree) delete fTree;
  fTree = new TTree("Segment Tree","Tree with segments");
  fBranch = fTree->Branch("Segment",psegment->IsA()->GetName(),&psegment,64000,1);
  delete psegment;
}              

//_____________________________________________________________________________
Bool_t AliTRDsegmentArrayBase::ConnectTree(const char * treeName)
{
  //connect tree from current directory  
  if (fTree){
    delete fTree;
    fTree = 0;
    fBranch = 0;
  }
  fTree =(TTree*)gDirectory->Get(treeName);
  if (fTree == 0)    return kFALSE;
  fBranch = fTree->GetBranch("Segment");
  if (fBranch==0) return kFALSE;
  MakeDictionary(TMath::Max(fNSegment,Int_t(fTree->GetEntries())));
  return kTRUE;
}

//_____________________________________________________________________________
AliTRDsegmentID *AliTRDsegmentArrayBase::LoadSegment(Int_t index)
{
  //
  //load segment with index to the memory
  //
  //
  if (fTreeIndex ==0 ) MakeDictionary(3000);
  //firstly try to load dictionary 
  if (fTreeIndex ==0 ) return 0;
  if (fBranch==0) return 0;
  if (index>fTreeIndex->fN) return 0;
  AliTRDsegmentID *s = (AliTRDsegmentID*)(*fSegment)[index];
  if (s==0)  s=  NewSegment();
  s->SetID(index);
  //  new AliTRDsegmentID(index);
  
  if (s!=0) {
    Int_t treeIndex =(*fTreeIndex)[index];
    if (treeIndex<1) return 0;
    else treeIndex--;   //I don't like it Int table I have index shifted by 1		       
    fBranch->SetAddress(&s);
    fTree->GetEvent(treeIndex);
    (*fSegment)[index] = (TObject*) s;
  }
  else 
    return 0;
  return s;
  //  AbstractMethod("LoadSegment");
}

//_____________________________________________________________________________
AliTRDsegmentID *AliTRDsegmentArrayBase::LoadEntry(Int_t index)
{
  //
  //load segment at position inex in tree  to the memory
  //
  //
  if (fBranch==0) return 0;
  if (index>fTree->GetEntries()) return 0;
  AliTRDsegmentID * s =  NewSegment();
  
  if (s) {
    fBranch->SetAddress(&s);
    fTree->GetEvent(index);
  }
  else 
    return 0;
  Int_t nindex = s->GetID();
  ClearSegment(nindex);
  (*fSegment)[nindex] = (TObject*) s;
  return s;
  //  AbstractMethod("LoadSegment");
}

void AliTRDsegmentArrayBase::StoreSegment(Int_t index)
{
  //
  //make segment persistent 
  //
  const AliTRDsegmentID *  segment = (*this)[index];
  if (segment == 0 ) return;
  if (fTree==0) MakeTree();
  fBranch->SetAddress(&segment);
  fTree->Fill();
}

//_____________________________________________________________________________
Bool_t  AliTRDsegmentArrayBase::MakeDictionary(Int_t size)
{
  //
  //create index table for tree
  //  
  if (size<1) return kFALSE;
  if (fTreeIndex) delete fTreeIndex;
  fTreeIndex = new AliTRDarrayI(); 
  fTreeIndex->Set(size);
  
  AliTRDsegmentID  segment;
  AliTRDsegmentID * psegment = &segment;
  fBranch->SetAddress(&psegment);
  TBranch * brindix = fTree->GetBranch("fSegmentID");
  Int_t nevent = (Int_t)fTree->GetEntries();  
  for (Int_t i = 0; i<nevent; i++){
    brindix->GetEvent(i);
    Int_t treeIndex=segment.GetID();
    if (fTreeIndex->fN<treeIndex) fTreeIndex->Expand(Int_t(Float_t(treeIndex)*1.5)+1);
    //    Int_t index = segment.GetID(); 
    (*fTreeIndex)[treeIndex]=i+1; // MI 19.5. I'm sorry  -index 0 couldn't be use in AliTRDarrayI   
  }
  return kTRUE;
}
Commit	Line	Data
f7336fa3	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
	16	/*
	17	$Log$
6f1e466d	18	Revision 1.1.4.1 2000/05/08 14:55:03 cblume
	19	Bug fixes
	20
	21	Revision 1.1 2000/02/28 19:02:56 cblume
	22	Add new TRD classes
	23
f7336fa3	24	*/
	25
	26	///////////////////////////////////////////////////////////////////////////////
	27	// //
	28	// Alice segment manager object //
	29	// //
	30	// AliTRDsegmentIDArray object is array of pointers to object derived from //
	31	// AliTRDsegmentID object //
	32	// AliTRDsegmentID - object in comparison with TObject enhalt //
	33	// additional information fSegmentID //
	34	// //
	35	///////////////////////////////////////////////////////////////////////////////
	36
	37	#include <TROOT.h>
	38	#include <TTree.h>
	39	#include "TClonesArray.h"
	40	#include "TDirectory.h"
	41	#include "AliTRDarrayI.h"
	42	#include "TError.h"
	43	#include "TClass.h"
	44
	45	#include "AliTRDsegmentID.h"
	46	#include "AliTRDsegmentArrayBase.h"
	47
f7336fa3	48	ClassImp(AliTRDsegmentArrayBase)
f7336fa3	49
6f1e466d	50	//_____________________________________________________________________________
f7336fa3	51	AliTRDsegmentArrayBase::AliTRDsegmentArrayBase()
	52	{
	53	//
	54	//
	55	//
6f1e466d	56
	57	fNSegment = 0;
	58	fSegment = 0;
f7336fa3	59	fTreeIndex = 0;
6f1e466d	60	fTree = 0;
	61	fClass = 0;
	62
f7336fa3	63	}
f7336fa3	64
6f1e466d	65	//_____________________________________________________________________________
f7336fa3	66	AliTRDsegmentArrayBase::AliTRDsegmentArrayBase(Text_t *classname, Int_t n)
	67	{
	68	//
	69	//constructor which
	70	//
	71	// Create an array of objects of classname. The class must inherit from
	72	// AliTRDsegmentID . The second argument adjust number of entries in
	73	// the array.
	74	fNSegment=0;
	75	fSegment =0;
	76	fTreeIndex = 0;
	77	fTree = 0;
	78	fClass = 0;
	79	SetClass(classname);
	80	if (MakeArray(n)==kFALSE){
	81	Error("AliTRDsegmentArrayBase", "can't allocate %d segments in memory",n);
	82	return;
	83	}
	84	}
	85
6f1e466d	86	//_____________________________________________________________________________
f7336fa3	87	Bool_t AliTRDsegmentArrayBase:: SetClass(Text_t *classname)
	88	{
	89	//
	90	//set class of stored object
	91	if ( fClass !=0 ) {
	92	delete fClass;
	93	fClass = 0;
	94	}
	95	if (fTree !=0) {
	96	delete fTree;
	97	fTree = 0;
	98	fBranch = 0;
	99	delete fTreeIndex;
	100	fTreeIndex = 0;
	101	}
	102	if (fSegment != 0) {
	103	fSegment->Delete();
	104	delete fSegment;
	105	fSegment = 0;
	106	}
	107	if (!gROOT)
	108	::Fatal("AliTRDsegmentArrayBase::AliTRDsegmentArrayBase", "ROOT system not initialized");
	109
	110	fClass = gROOT->GetClass(classname);
	111	if (!fClass) {
	112	Error("AliTRDsegmentArrayBase", "%s is not a valid class name", classname);
	113	return kFALSE;
	114	}
	115	if (!fClass->InheritsFrom(AliTRDsegmentID::Class())) {
	116	Error("AliTRDsegmentArrayBase", "%s does not inherit from AliTRDsegmentID", classname);
	117	return kFALSE;
	118	}
	119	return kTRUE;
	120	}
	121
6f1e466d	122	//_____________________________________________________________________________
f7336fa3	123	//Bool_t AliTRDsegmentArrayBase::ClassError( )
	124	//{
	125	//signalize class error
	126	// if (!fClass) {
	127	// Error("AliTRDsegmentArrayBase", "%s is not a valid class name", classname);
	128	// return kFALSE;
	129	// }
	130	//// return kFALSE;
	131	//}
	132
6f1e466d	133	//_____________________________________________________________________________
f7336fa3	134	AliTRDsegmentArrayBase::~AliTRDsegmentArrayBase()
	135	{
	136	if (fNSegment>0){
	137	fSegment->Delete();
	138	delete fSegment;
	139	}
	140	if (fTree) delete fTree;
	141	if (fTreeIndex) delete fTreeIndex;
	142	if (fClass!=0) delete fClass;
	143	}
	144
6f1e466d	145	//_____________________________________________________________________________
f7336fa3	146	AliTRDsegmentID * AliTRDsegmentArrayBase::NewSegment()
	147	{
	148	//
	149	//create object according class information
	150	if (fClass==0) return 0;
	151	AliTRDsegmentID * segment = (AliTRDsegmentID * )fClass->New();
	152	if (segment == 0) return 0;
	153	return segment;
	154	}
	155
6f1e466d	156	//_____________________________________________________________________________
f7336fa3	157	Bool_t AliTRDsegmentArrayBase::AddSegment(AliTRDsegmentID *segment)
	158	{
	159	//
	160	// add segment to array
	161	//
	162	if (segment==0) return kFALSE;
	163	if (fSegment==0) return kFALSE;
	164	if (fClass==0) return kFALSE;
	165	if (!(segment->IsA()->InheritsFrom(fClass))){
	166	Error("AliTRDsegmentArrayBase", "added class %s is not of proper type ",
	167	segment->IsA()->GetName());
	168	return kFALSE;
	169	}
	170	fSegment->AddAt(segment,segment->GetID());
	171	fNSegment = fSegment->GetLast()+1;
	172	return kTRUE;
	173	}
	174
6f1e466d	175	//_____________________________________________________________________________
f7336fa3	176	AliTRDsegmentID * AliTRDsegmentArrayBase::AddSegment(Int_t index)
	177	{
	178	//
	179	// add segment to array
	180	//
	181	if (fSegment==0) return 0;
	182	if (fClass==0) return 0;
	183	// AliTRDsegmentID * segment = (AliTRDsegmentID * )fClass->New();
	184	AliTRDsegmentID * segment = NewSegment();
	185	if (segment == 0) return 0;
	186	fSegment->AddAt(segment,index);
	187	segment->SetID(index);
	188	fNSegment = fSegment->GetLast()+1;
	189	return segment;
	190	}
	191
6f1e466d	192	//_____________________________________________________________________________
f7336fa3	193	Bool_t AliTRDsegmentArrayBase::MakeArray(Int_t n)
	194	{
	195	//
	196	//make array of pointers to Segments
	197	//
	198	if (fSegment) {
	199	fSegment->Delete();
	200	delete fSegment;
	201	}
	202	if (fTreeIndex) delete fTreeIndex;
	203	fSegment = new TObjArray(n);
	204	fTreeIndex = new AliTRDarrayI;
	205	fTreeIndex->Set(n);
	206	fNSegment=n;
	207	if ( (fSegment) && (fTreeIndex)) return kTRUE;
	208	else return kFALSE;
	209	}
	210
6f1e466d	211	//_____________________________________________________________________________
f7336fa3	212	void AliTRDsegmentArrayBase::ClearSegment(Int_t index)
	213	{
	214	//
	215	//remove segment from active memory
	216	//
	217	if ((*fSegment)[index]){
	218	// (*fSegment)[index]->Delete(); //not working for TClonesArray
	219	delete (*fSegment)[index]; //because problem with deleting TClonesArray
	220	fSegment->RemoveAt(index);
	221	}
	222	}
	223
6f1e466d	224	//_____________________________________________________________________________
f7336fa3	225	void AliTRDsegmentArrayBase::MakeTree()
	226	{
	227	// AliTRDsegmentID segment;
	228	AliTRDsegmentID * psegment = NewSegment();
	229	if (fTree) delete fTree;
	230	fTree = new TTree("Segment Tree","Tree with segments");
	231	fBranch = fTree->Branch("Segment",psegment->IsA()->GetName(),&psegment,64000,1);
	232	delete psegment;
	233	}
	234
6f1e466d	235	//_____________________________________________________________________________
f7336fa3	236	Bool_t AliTRDsegmentArrayBase::ConnectTree(const char * treeName)
	237	{
	238	//connect tree from current directory
	239	if (fTree){
	240	delete fTree;
	241	fTree = 0;
	242	fBranch = 0;
	243	}
	244	fTree =(TTree*)gDirectory->Get(treeName);
	245	if (fTree == 0) return kFALSE;
	246	fBranch = fTree->GetBranch("Segment");
	247	if (fBranch==0) return kFALSE;
	248	MakeDictionary(TMath::Max(fNSegment,Int_t(fTree->GetEntries())));
	249	return kTRUE;
	250	}
	251
6f1e466d	252	//_____________________________________________________________________________
f7336fa3	253	AliTRDsegmentID *AliTRDsegmentArrayBase::LoadSegment(Int_t index)
	254	{
	255	//
	256	//load segment with index to the memory
	257	//
	258	//
	259	if (fTreeIndex ==0 ) MakeDictionary(3000);
	260	//firstly try to load dictionary
	261	if (fTreeIndex ==0 ) return 0;
	262	if (fBranch==0) return 0;
	263	if (index>fTreeIndex->fN) return 0;
	264	AliTRDsegmentID s = (AliTRDsegmentID)(*fSegment)[index];
	265	if (s==0) s= NewSegment();
	266	s->SetID(index);
	267	// new AliTRDsegmentID(index);
	268
	269	if (s!=0) {
	270	Int_t treeIndex =(*fTreeIndex)[index];
	271	if (treeIndex<1) return 0;
	272	else treeIndex--; //I don't like it Int table I have index shifted by 1
	273	fBranch->SetAddress(&s);
	274	fTree->GetEvent(treeIndex);
	275	(fSegment)[index] = (TObject) s;
	276	}
	277	else
	278	return 0;
	279	return s;
	280	// AbstractMethod("LoadSegment");
	281	}
6f1e466d	282
6f1e466d	283	//_____________________________________________________________________________
f7336fa3	284	AliTRDsegmentID *AliTRDsegmentArrayBase::LoadEntry(Int_t index)
	285	{
	286	//
	287	//load segment at position inex in tree to the memory
	288	//
	289	//
	290	if (fBranch==0) return 0;
	291	if (index>fTree->GetEntries()) return 0;
	292	AliTRDsegmentID * s = NewSegment();
	293
	294	if (s) {
	295	fBranch->SetAddress(&s);
	296	fTree->GetEvent(index);
	297	}
	298	else
	299	return 0;
	300	Int_t nindex = s->GetID();
	301	ClearSegment(nindex);
	302	(fSegment)[nindex] = (TObject) s;
	303	return s;
	304	// AbstractMethod("LoadSegment");
	305	}
	306
	307	void AliTRDsegmentArrayBase::StoreSegment(Int_t index)
	308	{
	309	//
	310	//make segment persistent
	311	//
	312	const AliTRDsegmentID * segment = (*this)[index];
	313	if (segment == 0 ) return;
	314	if (fTree==0) MakeTree();
	315	fBranch->SetAddress(&segment);
	316	fTree->Fill();
	317	}
	318
6f1e466d	319	//_____________________________________________________________________________
f7336fa3	320	Bool_t AliTRDsegmentArrayBase::MakeDictionary(Int_t size)
	321	{
	322	//
	323	//create index table for tree
	324	//
	325	if (size<1) return kFALSE;
	326	if (fTreeIndex) delete fTreeIndex;
	327	fTreeIndex = new AliTRDarrayI();
	328	fTreeIndex->Set(size);
	329
	330	AliTRDsegmentID segment;
	331	AliTRDsegmentID * psegment = &segment;
	332	fBranch->SetAddress(&psegment);
	333	TBranch * brindix = fTree->GetBranch("fSegmentID");
	334	Int_t nevent = (Int_t)fTree->GetEntries();
	335	for (Int_t i = 0; i<nevent; i++){
	336	brindix->GetEvent(i);
	337	Int_t treeIndex=segment.GetID();
	338	if (fTreeIndex->fN<treeIndex) fTreeIndex->Expand(Int_t(Float_t(treeIndex)*1.5)+1);
	339	// Int_t index = segment.GetID();
	340	(*fTreeIndex)[treeIndex]=i+1; // MI 19.5. I'm sorry -index 0 couldn't be use in AliTRDarrayI
	341	}
	342	return kTRUE;
	343	}