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