TPC/AliSegmentArray.cxx

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