TRD/AliTRDsegmentArrayBase.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.3  2000/06/07 16:27:01  cblume
  19 Try to remove compiler warnings on Sun and HP
  20
  21 Revision 1.2  2000/05/08 16:17:27  cblume
  22 Merge TRD-develop
  23
  24 Revision 1.1.4.1  2000/05/08 14:55:03  cblume
  25 Bug fixes
  26
  27 Revision 1.1  2000/02/28 19:02:56  cblume
  28 Add new TRD classes
  29
  30 */
  31
  32 ///////////////////////////////////////////////////////////////////////////////
  33 //                                                                           //
  34 //  Alice segment manager base class                                         //
  35 //                                                                           //
  36 ///////////////////////////////////////////////////////////////////////////////
  37
  38 #include  <TROOT.h>
  39 #include <TTree.h>
  40 #include "TClonesArray.h"
  41 #include "TDirectory.h"
  42 #include "AliTRDarrayI.h"
  43 #include "TError.h"
  44 #include "TClass.h"
  45
  46 #include "AliTRDsegmentID.h"
  47 #include "AliTRDsegmentArrayBase.h"
  48
  49 ClassImp(AliTRDsegmentArrayBase)
  50
  51 //_____________________________________________________________________________
  52 AliTRDsegmentArrayBase::AliTRDsegmentArrayBase():TNamed()
  53 {
  54   //
  55   // AliTRDsegmentArrayBase default constructor
  56   //
  57
  58   fNSegment  = 0;
  59   fSegment   = 0;
  60   fTreeIndex = 0;
  61   fTree      = 0;
  62   fClass     = 0;
  63
  64 }
  65
  66 //_____________________________________________________________________________
  67 AliTRDsegmentArrayBase::AliTRDsegmentArrayBase(Text_t *classname, Int_t n)
  68 {
  69   //
  70   //  Create an array of objects of <classname>. The class must inherit from
  71   //  AliTRDsegmentID. The second argument sets the number of entries in
  72   //  the array.
  73   //
  74
  75   fNSegment  = 0;
  76   fSegment   = 0;
  77   fTreeIndex = 0;
  78   fTree      = 0;
  79   fClass     = 0;
  80
  81   SetClass(classname);
  82
  83   if (MakeArray(n) == kFALSE) {
  84      Error("AliTRDsegmentArrayBase","Cannot allocate %d segments in memory",n);
  85      return;
  86   }
  87
  88 }
  89
  90 //_____________________________________________________________________________
  91 AliTRDsegmentArrayBase::AliTRDsegmentArrayBase(AliTRDsegmentArrayBase &a)
  92 {
  93   //
  94   // AliTRDsegmentArrayBase copy constructor
  95   //
  96
  97   a.Copy(*this);
  98
  99 }
 100
 101 //_____________________________________________________________________________
 102 AliTRDsegmentArrayBase::~AliTRDsegmentArrayBase()
 103 {
 104   //
 105   // AliTRDsegmentArrayBase destructor
 106   //
 107
 108   if (fNSegment){
 109     fSegment->Delete();
 110     delete fSegment;
 111   }
 112
 113   if (fTree)      delete fTree;
 114   if (fTreeIndex) delete fTreeIndex;
 115   if (fClass)     delete fClass;
 116
 117 }
 118
 119 //_____________________________________________________________________________
 120 void AliTRDsegmentArrayBase::Copy(AliTRDsegmentArrayBase &a)
 121 {
 122   //
 123   // Copy function
 124   //
 125
 126   TNamed::Copy(a);
 127
 128   fSegment->Copy(*a.fSegment);
 129   fTreeIndex->Copy(*a.fTreeIndex);
 130   fClass->Copy(*a.fClass);
 131
 132   a.fNSegment = fNSegment;
 133
 134 }
 135
 136 //_____________________________________________________________________________
 137 Bool_t AliTRDsegmentArrayBase::SetClass(Text_t *classname)
 138 {
 139   //
 140   // Sets the classname of the stored object
 141   //
 142
 143   if (fClass   != 0) {
 144     delete fClass;
 145     fClass = 0;
 146   }
 147   if (fTree    != 0) {
 148     delete fTree;
 149     fTree      = 0;
 150     fBranch    = 0;
 151     delete fTreeIndex;
 152     fTreeIndex = 0;
 153   }
 154   if (fSegment != 0) {
 155     fSegment->Delete();
 156     delete fSegment;
 157     fSegment   = 0;
 158   }
 159
 160   if (!gROOT) ::Fatal("AliTRDsegmentArrayBase::AliTRDsegmentArrayBase"
 161                      ,"ROOT system not initialized");
 162
 163    fClass = gROOT->GetClass(classname);
 164    if (!fClass) {
 165      Error("AliTRDsegmentArrayBase","%s is not a valid class name",classname);
 166      return kFALSE;
 167    }
 168    if (!fClass->InheritsFrom(AliTRDsegmentID::Class())) {
 169      Error("AliTRDsegmentArrayBase"
 170           ,"%s does not inherit from AliTRDsegmentID",classname);
 171      return kFALSE;
 172    }
 173
 174    return kTRUE;
 175
 176 }
 177
 178 //_____________________________________________________________________________
 179 AliTRDsegmentID * AliTRDsegmentArrayBase::NewSegment()
 180 {
 181   //
 182   // Create a new object according to the class information
 183   //
 184
 185   if (fClass  == 0) return 0;
 186
 187   AliTRDsegmentID *segment = (AliTRDsegmentID *) fClass->New();
 188   if (segment == 0) return 0;
 189
 190   return segment;
 191
 192 }
 193
 194 //_____________________________________________________________________________
 195 Bool_t AliTRDsegmentArrayBase::AddSegment(AliTRDsegmentID *segment)
 196 {
 197   //
 198   // Add a segment to the array
 199   //
 200
 201   if (segment  == 0) return kFALSE;
 202   if (fSegment == 0) return kFALSE;
 203   if (fClass   == 0) return kFALSE;
 204
 205   if (!(segment->IsA()->InheritsFrom(fClass))) {
 206     Error("AliTRDsegmentArrayBase","added class %s is not of proper type",
 207           segment->IsA()->GetName());
 208     return kFALSE;
 209   }
 210
 211   fSegment->AddAt(segment,segment->GetID());
 212   fNSegment = fSegment->GetLast() + 1;
 213
 214   return kTRUE;
 215
 216 }
 217
 218 //_____________________________________________________________________________
 219 AliTRDsegmentID * AliTRDsegmentArrayBase::AddSegment(Int_t index)
 220 {
 221   //
 222   // Add a segment to the array
 223   //
 224
 225   if (fSegment == 0) return 0;
 226   if (fClass   == 0) return 0;
 227
 228   AliTRDsegmentID *segment = NewSegment();
 229   if (segment  == 0) return 0;
 230
 231   fSegment->AddAt(segment,index);
 232   segment->SetID(index);
 233   fNSegment = fSegment->GetLast() + 1;
 234
 235   return segment;
 236
 237 }
 238
 239 //_____________________________________________________________________________
 240 Bool_t AliTRDsegmentArrayBase::MakeArray(Int_t n)
 241 {
 242   //
 243   // Create an array of pointers to the segments
 244   //
 245
 246   if (fSegment) {
 247     fSegment->Delete();
 248     delete fSegment;
 249   }
 250   if (fTreeIndex) delete fTreeIndex;
 251
 252   fSegment   = new TObjArray(n);
 253   fTreeIndex = new AliTRDarrayI;
 254   fTreeIndex->Set(n);
 255   fNSegment  = n;
 256   if ((fSegment) && (fTreeIndex))
 257     return kTRUE;
 258   else
 259     return kFALSE;
 260
 261 }
 262
 263 //_____________________________________________________________________________
 264 void AliTRDsegmentArrayBase::ClearSegment(Int_t index)
 265 {
 266   //
 267   // Remove a segment from the active memory
 268   //
 269
 270   if ((*fSegment)[index]){
 271     delete (*fSegment)[index]; // because problem with deleting TClonesArray
 272     fSegment->RemoveAt(index);
 273   }
 274
 275 }
 276
 277 //_____________________________________________________________________________
 278 void AliTRDsegmentArrayBase::MakeTree()
 279 {
 280   //
 281   // Create a tree for the segment
 282   //
 283
 284   AliTRDsegmentID *psegment = NewSegment();
 285
 286   if (fTree) delete fTree;
 287   fTree   = new TTree("Segment Tree","Tree with segments");
 288
 289   fBranch = fTree->Branch("Segment",psegment->IsA()->GetName(),&psegment,64000,1);
 290
 291   delete psegment;
 292
 293 }
 294
 295 //_____________________________________________________________________________
 296 Bool_t AliTRDsegmentArrayBase::ConnectTree(const char * treeName)
 297 {
 298   //
 299   // Connect a tree from current directory
 300   //
 301
 302   if (fTree){
 303     delete fTree;
 304     fTree   = 0;
 305     fBranch = 0;
 306   }
 307
 308   fTree   = (TTree*) gDirectory->Get(treeName);
 309   if (fTree   == 0) return kFALSE;
 310   fBranch = fTree->GetBranch("Segment");
 311   if (fBranch == 0) return kFALSE;
 312
 313   MakeDictionary(TMath::Max(fNSegment,Int_t(fTree->GetEntries())));
 314
 315   return kTRUE;
 316
 317 }
 318
 319 //_____________________________________________________________________________
 320 AliTRDsegmentID *AliTRDsegmentArrayBase::LoadSegment(Int_t index)
 321 {
 322   //
 323   // Load a segment with index <index> into the memory
 324   //
 325
 326   if (fTreeIndex == 0) MakeDictionary(3000);
 327
 328   // First try to load dictionary
 329   if (fTreeIndex == 0)        return 0;
 330   if (fBranch    == 0)        return 0;
 331   if (index > fTreeIndex->fN) return 0;
 332   AliTRDsegmentID *s = (AliTRDsegmentID*) (*fSegment)[index];
 333   if (s == 0) s = NewSegment();
 334   s->SetID(index);
 335
 336   if (s != 0) {
 337     Int_t treeIndex = (*fTreeIndex)[index];
 338     if (treeIndex < 1)
 339       return 0;
 340     else
 341       treeIndex--;
 342     fBranch->SetAddress(&s);
 343     fTree->GetEvent(treeIndex);
 344     (*fSegment)[index] = (TObject*) s;
 345   }
 346   else
 347     return 0;
 348
 349   return s;
 350
 351 }
 352
 353 //_____________________________________________________________________________
 354 AliTRDsegmentID *AliTRDsegmentArrayBase::LoadEntry(Int_t index)
 355 {
 356   //
 357   // Load a segment at position <index> in the tree into the memory
 358   //
 359
 360   if (fBranch == 0)                return 0;
 361   if (index > fTree->GetEntries()) return 0;
 362
 363   AliTRDsegmentID *s = NewSegment();
 364   if (s) {
 365     fBranch->SetAddress(&s);
 366     fTree->GetEvent(index);
 367   }
 368   else
 369     return 0;
 370
 371   Int_t nindex = s->GetID();
 372   ClearSegment(nindex);
 373   (*fSegment)[nindex] = (TObject *) s;
 374
 375   return s;
 376
 377 }
 378
 379 //_____________________________________________________________________________
 380 void AliTRDsegmentArrayBase::StoreSegment(Int_t index)
 381 {
 382   //
 383   // Make a segment persistent
 384   //
 385
 386   const AliTRDsegmentID *kSegment = (*this)[index];
 387   if (kSegment == 0) return;
 388   if (fTree    == 0) MakeTree();
 389   fBranch->SetAddress(&kSegment);
 390   fTree->Fill();
 391
 392 }
 393
 394 //_____________________________________________________________________________
 395 Bool_t  AliTRDsegmentArrayBase::MakeDictionary(Int_t size)
 396 {
 397   //
 398   // Create an index table for the tree
 399   //
 400
 401   if (size < 1)   return kFALSE;
 402   if (fTreeIndex) delete fTreeIndex;
 403
 404   fTreeIndex = new AliTRDarrayI();
 405   fTreeIndex->Set(size);
 406
 407   AliTRDsegmentID   segment;
 408   AliTRDsegmentID *psegment = &segment;
 409
 410   fBranch->SetAddress(&psegment);
 411   TBranch *brindix = fTree->GetBranch("fSegmentID");
 412
 413   Int_t nevent = (Int_t) fTree->GetEntries();
 414   for (Int_t i = 0; i < nevent; i++){
 415     brindix->GetEvent(i);
 416     Int_t treeIndex = segment.GetID();
 417     if (fTreeIndex->fN < treeIndex)
 418       fTreeIndex->Expand(Int_t (Float_t(treeIndex) * 1.5) + 1);
 419     (*fTreeIndex)[treeIndex] = i + 1;
 420   }
 421
 422   return kTRUE;
 423
 424 }
 425
 426 //_____________________________________________________________________________
 427 const AliTRDsegmentID * AliTRDsegmentArrayBase::operator[](Int_t i)
 428 {
 429   //
 430   // Returns a segment with the given index <i>
 431   //
 432
 433   if ((i < 0) || (i >= fNSegment)) return 0;
 434   return (AliTRDsegmentID *) fSegment->At(i);
 435
 436 }
 437
 438 //_____________________________________________________________________________
 439 const AliTRDsegmentID *AliTRDsegmentArrayBase::At(Int_t i)
 440 {
 441   //
 442   // Returns a segment with the given index <i>
 443   //
 444
 445   if ((i < 0) || (i >= fNSegment)) return 0;
 446   return (AliTRDsegmentID *)((*fSegment)[i]);
 447
 448 }