[u/mrichter/AliRoot.git] / TPC / AliSegmentArray.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.2.4.1  2000/06/25 08:38:41  kowal2
Splitted from AliTPCtracking

Revision 1.2  2000/04/17 09:37:33  kowal2
removed obsolete AliTPCDigitsDisplay.C

Revision 1.1.4.2  2000/04/10 11:39:36  kowal2

New data structure handling

*/

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

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

#include "AliSegmentID.h"
#include "AliSegmentArray.h"
#include "TObjString.h"


//_____________________________________________________________________________
ClassImp(AliSegmentArray)
  
AliSegmentArray::AliSegmentArray()
{
  //
  //
  //
  fNSegment=0;
  fSegment =0; 
  fTreeIndex = 0;
  fTree  = 0;
  fClass = 0;
}

AliSegmentArray::AliSegmentArray(Text_t *classname, Int_t n)
{
  //
  //constructor which 
  // 
  //  Create an array of objects of classname. The class must inherit from
  //  AliSegmentID .  The second argument adjust number of entries in 
  //  the array.
  fNSegment=0;
  fSegment =0; 
  fTreeIndex = 0;
  fTree  = 0;
  fClass = 0;
  SetName("SegmentArray");
  SetTitle("SegmentArray");

  SetClass(classname);
  if (MakeArray(n)==kFALSE){
     Error("AliSegmentArray", "can't allocate %d segments in memory",n);
     return;
   }
}

AliSegmentArray::AliSegmentArray(const AliSegmentArray &segment)
{
  //
  //copy constructor
  // to be later implemented
}

AliSegmentArray &AliSegmentArray::operator = (const AliSegmentArray & segment)
{
  //assignment operator
  //to be later implemented
  return (*this);
}

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


Bool_t AliSegmentArray::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("AliSegmentArray::AliSegmentArray", "ROOT system not initialized");
   
   fClass = gROOT->GetClass(classname);
   if (!fClass) {
      Error("AliSegmentArray", "%s is not a valid class name", classname);
      return kFALSE;
   }
   if (!fClass->InheritsFrom(AliSegmentID::Class())) {
      Error("AliSegmentArray", "%s does not inherit from AliSegmentID", classname);
      return kFALSE;
   }  
   return kTRUE;
}


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


Bool_t AliSegmentArray::AddSegment(AliSegmentID *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("AliSegmentArray", "added class %s  is not of proper type ",
	  segment->IsA()->GetName());
      return kFALSE;
  }
  fSegment->AddAt(segment,segment->GetID());
  fNSegment = fSegment->GetLast()+1;
  return kTRUE;
}

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


void AliSegmentArray::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);
  }
}


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


void AliSegmentArray::MakeTree()
{
  //  AliSegmentID  segment;
  AliSegmentID * 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  AliSegmentArray::MakeDictionary(Int_t size)
{
  //
  //create index table for tree
  //  
  if (size<1) return kFALSE;
  if (fTreeIndex) delete fTreeIndex;
  fTreeIndex = new AliArrayI(); 
  fTreeIndex->Set(size);
  
  AliSegmentID  segment;
  AliSegmentID * 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; //  
  }
  return kTRUE;
}

Bool_t AliSegmentArray::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())));
  MakeArray(fTreeIndex->fN);
  return kTRUE;
}

AliSegmentID *AliSegmentArray::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;
  AliSegmentID *s = (AliSegmentID*)(*fSegment)[index];
  if (s==0)  s=  NewSegment();
  s->SetID(index);
  //  new AliSegmentID(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;

}
AliSegmentID *AliSegmentArray::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;
  AliSegmentID * 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;
}

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


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