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.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
  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
  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
 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
 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   //
 340   const AliSegmentID *  ksegment = (*this)[index];
 341   if (ksegment == 0 ) return;
 342   if (fTree==0) MakeTree();
 343   fBranch->SetAddress(&ksegment);
 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 }