TPC/AliSimDigits.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:37:42  kowal2
  19
  20 Digits handling in a new data structure
  21
  22 */
  23
  24
  25 ///////////////////////////////////////////////////////////////////////////////
  26 //                                                                           //
  27 //  Alice segment manager object                                             //
  28 //
  29 //  AliSimDigits object   (derived from AliDigits)                            //
  30 //  provide additional track information to digit                            //
  31 //
  32 //   Origin: Marian Ivanov  GSI Darmstadt                                     //
  33 //
  34 //                                                                           //
  35 //                                                                          //
  36 ///////////////////////////////////////////////////////////////////////////////
  37
  38 #include "TClass.h"
  39 #include <iostream.h>
  40 #include "TError.h"
  41 #include "AliSegmentID.h"
  42 #include "AliH2F.h"
  43 #include "AliArrayI.h"
  44 #include "AliArrayS.h"
  45 #include "AliDigits.h"
  46 #include "AliSimDigits.h"
  47 #include "AliTPC.h"
  48
  49
  50
  51 //_____________________________________________________________________________
  52 //_____________________________________________________________________________
  53 //_____________________________________________________________________________
  54 ClassImp(AliSimDigits)
  55
  56 AliSimDigits::AliSimDigits()
  57 {
  58   //  AliDigits::Invalite();
  59   fTracks = 0;
  60   fTrIndex = 0;
  61   InvalidateTrack();
  62 }
  63 AliSimDigits::~AliSimDigits()
  64 {
  65   //  AliDigits::Invalidate();
  66   if (fTracks != 0) fTracks->Delete();
  67   if (fTrIndex != 0) fTrIndex->Delete();
  68
  69 }
  70
  71 void AliSimDigits::InvalidateTrack()
  72 {
  73   //
  74   //set default (invalid parameters)
  75   if ( fTracks != 0) delete fTracks;
  76   fTracks = new AliArrayI;
  77   if ( fTrIndex  != 0) delete fTrIndex;
  78   fTrIndex = new AliArrayI;
  79
  80   for (Int_t i = 0; i<3; i++){
  81     fTracks->Set(0);
  82     fTrIndex->Set(0);
  83   }
  84 }
  85
  86 void  AliSimDigits::AllocateTrack(Int_t length)
  87 {
  88   //
  89   //construct empty buffer fElements and fTracks with size fNrows x fNcols x
  90   //length
  91   InvalidateTrack();
  92   fNlevel = length;
  93   fTracks->Set(fNcols*fNrows*fNlevel);
  94   fTrIndex->Set(0);
  95   fTrBufType =0;
  96 }
  97
  98 Int_t AliSimDigits::GetTrackID(Int_t row, Int_t column, Int_t level)
  99 {
 100   //
 101   //Get track ID
 102   if (fTrBufType == 0) return  GetTrackIDFast(row, column,level);
 103   if (fTrBufType == 1) return  GetTrackID1(row, column,level);
 104   if (fTrBufType == 2) return  GetTrackID2(row, column,level);
 105   return 0;
 106 }
 107
 108 void AliSimDigits::ExpandTrackBuffer()
 109 {
 110   //
 111   //expand buffer to two dimensional array
 112   if (fTrBufType<0)  {
 113     Error("ExpandBuffer", "buffer doesn't exist");
 114     return;
 115   }
 116   if (fTrBufType==0)      return;  //buffer expanded
 117   if (fTrBufType==1)  {ExpandTrackBuffer1(); return;}
 118   if (fTrBufType==2)  ExpandTrackBuffer2();
 119
 120 }
 121
 122 void AliSimDigits::CompresTrackBuffer(Int_t bufType)
 123 {
 124   //
 125   //compres buffer according buffertype algorithm
 126   //
 127   if (fTrBufType<0)  {
 128     Error("CompressBuffer", "buffer doesn't exist");
 129     return;
 130   }
 131   if (fTrBufType == bufType) return;
 132   //
 133   if (fTrBufType>0) ExpandTrackBuffer();
 134   if (fTrBufType !=0)  {
 135     Error("CompressBuffer", "buffer doesn't exist");
 136     return;
 137   }
 138   //compress buffer of type 1
 139
 140   if (bufType==1)      {CompresTrackBuffer1();return;}
 141   if (bufType==2)      CompresTrackBuffer2();
 142
 143 }
 144
 145 Int_t  AliSimDigits::GetTrackID1(Int_t row, Int_t column, Int_t level)
 146 {
 147   //return  track ID of digits - for buffer compresion 2
 148   Int_t i,n1,n2;
 149   i = level*fNcols+column;
 150   if ( (i+1)>=fTrIndex->fN) n2 = fTracks->fN;
 151   else
 152     n2 = fTrIndex->At(i+1);
 153   n1 = fTrIndex->At(i);
 154   Int_t rownew = 0;
 155   Int_t rowold=0;
 156   Int_t ID;
 157   for (i = n1;(i<n2);i++){
 158     ID = 0;
 159     Int_t num = fTracks->At(i);
 160     if (num<0) {
 161       rownew-=num;
 162       rowold = rownew;
 163       i++;
 164       if (i<n2){
 165         num = fTracks->At(i);
 166         rownew+=num;
 167         i++;
 168         ID = fTracks->At(i);
 169       }
 170     }
 171     else {
 172       rowold = rownew;
 173       rownew+=num;
 174       i++;
 175       ID = fTracks->At(i);
 176     }
 177 ID-=2;
 178     if ( (row>=rowold) && (row<=rownew) ) return ID;
 179     if (row < rownew ) return -2; //empty track
 180   }
 181   return -2;
 182 }
 183
 184 void  AliSimDigits::ExpandTrackBuffer1()
 185 {
 186   //
 187   //expand  track compressed according algorithm 1 (track ID comression independent to the digit compression)
 188   // !!in expanded tracks we don't use fTrIndex array
 189   //
 190   fTrBufType = 0;
 191   Int_t i,j;
 192   Int_t all   = fNrows*fNcols;  //total number of digits
 193   Int_t elems = all*fNlevel;  //length of the buffer
 194
 195   AliArrayI * buf = new AliArrayI;
 196   buf->Set(elems);
 197   fTrIndex->Set(0);
 198   //
 199   Int_t level = 0;
 200   Int_t col=0;
 201   Int_t row = 0;
 202   Int_t N=fTracks->fN;
 203   //
 204   for (i=0;i<N;i++){
 205     //oposite signa means how many unwrited (under threshold) values
 206     Int_t num = fTracks->At(i);
 207     if (num<0) row-=num;   //negative number mean number of zeroes (no tracks of gibven level no need to write to array)
 208     else {
 209       i++;
 210       Int_t ID =  fTracks->At(i);
 211       for (j = 0; j<num; j++,row++) (*buf)[level*all+col*fNrows+row]=ID;
 212     }
 213     if (row>=fNrows) {
 214       row=0;
 215       col++;
 216     }
 217     if (col>=fNcols) {
 218       col=0;
 219       level++;
 220     }
 221   }//end of loop over digits
 222   delete fTracks;
 223   fTracks = buf;
 224 }
 225
 226 void  AliSimDigits::CompresTrackBuffer1()
 227 {
 228   //
 229   //comress track according algorithm 1 (track ID comression independent to the digit compression)
 230   //
 231   fTrBufType = 1;
 232
 233   AliArrayI *  buf = new AliArrayI;   //create  new buffer
 234   buf->Set(fNrows*fNcols*fNlevel); //lets have the nearly the "worst case"
 235   AliArrayI *  index = new AliArrayI;
 236   index->Set(fNcols*fNlevel);
 237
 238   Int_t icurrent=-1;  //current index
 239   Int_t izero;      //number of zero
 240   Int_t inum;      //number of digits  with the same current track ID
 241   Int_t lastID =0;  //last track ID
 242   for (Int_t lev =0; lev<fNlevel; lev++){    //loop over levels
 243     for (Int_t col = 0; col<fNcols; col++){    //loop over columns
 244       izero = 0;
 245       inum =  0;
 246       lastID = 0;
 247       (*index)[lev*fNcols+col]=icurrent+1;//set collumn pointer
 248       Int_t ID;  //current ID
 249       for (Int_t row = 0; row< fNrows;row++){ //loop over rows
 250         ID = GetTrackIDFast(row,col,lev);
 251         if (ID <= 0) {
 252           if ( inum> 0 ) { //if we have some tracks in buffer
 253             icurrent++;
 254             if ((icurrent+1)>=buf->fN) buf->Expand(icurrent*2);
 255             (*buf)[icurrent] = inum;
 256             icurrent++;
 257             (*buf)[icurrent] = lastID;
 258             inum = 0;
 259             lastID = 0;
 260           }
 261           izero++;
 262         }
 263         else
 264           if (ID != lastID)
 265             if ( izero > 0 ) {
 266               //if we have currently izero count of non tracks digits
 267               icurrent++;
 268               if (icurrent>=buf->fN) buf->Expand(icurrent*2);
 269               (*buf)[icurrent]= -izero;  //write how many under zero
 270               inum++;
 271               izero = 0;
 272               lastID = ID;
 273             }
 274             else{
 275               //if we change track ID from another track ID
 276               icurrent++;
 277               if ((icurrent+1)>=buf->fN) buf->Expand(icurrent*2);
 278               (*buf)[icurrent] = inum;
 279               icurrent++;
 280               (*buf)[icurrent] = lastID;
 281               lastID = ID;
 282               inum = 1;
 283               izero = 0;
 284             }
 285           else {
 286             inum++;
 287           }
 288
 289       }//end of loop over rows
 290       if ( izero > 0 ) {
 291         //if we have currently izero count of non tracks digits
 292         icurrent++;
 293         if (icurrent>=buf->fN) buf->Expand(icurrent*2);
 294         (*buf)[icurrent]= -izero;  //write how many under zero
 295       }
 296       if ( inum> 0 ) { //if we have some tracks in buffer
 297         icurrent++;
 298         if ((icurrent+1)>=buf->fN) buf->Expand(icurrent*2);
 299         (*buf)[icurrent] = inum;
 300         icurrent++;
 301         (*buf)[icurrent] = ID;
 302       }
 303     }//end of loop over columns
 304   }//end of loop over differnet track level
 305   buf->Expand(icurrent+1);
 306   delete fTracks;
 307   fTracks = buf;
 308   delete fTrIndex;
 309   fTrIndex = index;
 310 }
 311
 312
 313
 314 void  AliSimDigits::ExpandTrackBuffer2()
 315 {
 316   //
 317   //comress track according algorithm 2 (track ID comression according  digit compression)
 318   fTrBufType = 0;
 319 }
 320
 321 void  AliSimDigits::CompresTrackBuffer2()
 322 {
 323   //
 324   //comress track according algorithm 2 (track ID comression according  digit compression)
 325   fTrBufType = 2;
 326 }
 327
 328
 329 Int_t  AliSimDigits::GetTrackID2(Int_t row, Int_t column, Int_t level)
 330 {
 331   //returnb track ID of digits - for buffer compresion 2
 332   return -2;
 333 }
 334
 335
 336
 337 AliH2F *  AliSimDigits::DrawTracks( const char *option,Int_t level,
 338                               Float_t x1, Float_t x2, Float_t y1, Float_t y2)
 339 {
 340   //
 341   //draw digits in given array
 342   //
 343   //make digits histo
 344   char ch[30];
 345   sprintf(ch,"Track Segment_%d level %d ",GetID(),level );
 346   if ( (fNrows<1)|| (fNcols<1)) {
 347     return 0;
 348   }
 349   AliH2F * his  = new AliH2F("Track histo",ch,fNrows,0,fNrows,fNcols,0,fNcols);
 350   ExpandTrackBuffer();
 351   //set histogram  values
 352   for (Int_t i = 0; i<fNrows;i++)
 353     for (Int_t j = 0; j<fNcols;j++)
 354         his->Fill(i,j,GetTrackIDFast(i,j,level));
 355   if (x1>=0) {
 356       AliH2F *h2fsub = his->GetSubrange2d(x1,x2,y1,y2);
 357       delete his;
 358       his=h2fsub;
 359   }
 360   if (his==0) return 0;
 361   if (option!=0) his->Draw(option);
 362   else his->Draw();
 363   return his;
 364 }
 365
 366 TClonesArray *  AliSimDigits::GenerTPCClonesArray(TClonesArray * arr)
 367 {
 368   //
 369   //generate TClonnesArray of digits
 370   //
 371   TClonesArray * digits;
 372   if (arr==0)  digits=new TClonesArray("AliTPCdigit",300);
 373   else digits = arr;
 374   Int_t index = digits->GetEntriesFast();
 375   for (Int_t row =0; row<fNrows; row++)
 376     for (Int_t col =0; col<fNcols; col++){
 377       Int_t amp = GetDigit(row,col);
 378       if (amp>GetThreshold()){
 379         AliTPCdigit dig;
 380         dig.fPad = col;
 381         dig.fTime = row;
 382         dig.fSignal= amp;
 383         dig.fPadRow =fSegmentID;
 384         dig.fSector =fSegmentID;
 385         dig.fTracks[0]= GetTrackID(row,col,0);
 386         dig.fTracks[1]= GetTrackID(row,col,1);
 387         dig.fTracks[2]= GetTrackID(row,col,2);
 388         TClonesArray &ldigits = *digits;
 389         new(ldigits[index++]) AliTPCdigit(dig);
 390       }
 391     }
 392   return digits;
 393 }
 394