ITS/AliITSpList.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 /* $Id$ */
  16
  17 #include <stdio.h>
  18 #include <stdlib.h>
  19 #include <iostream.h>
  20 #include <iomanip.h>
  21 #include <TObjArray.h>
  22 #include <TRandom.h>
  23 #include <TMath.h>
  24
  25 #include "AliITSpList.h"
  26
  27 //______________________________________________________________________
  28
  29 ClassImp(AliITSpList);
  30 //______________________________________________________________________
  31 AliITSpList::AliITSpList(){
  32     // Default constructor
  33     // Inputs:
  34     //    none.
  35     // Outputs:
  36     //    none.
  37     // Return:
  38     //    A zeroed/empty AliITSpList class.
  39
  40     fNi = 0;
  41     fNj = 0;
  42     fa  = 0;
  43 }
  44 //______________________________________________________________________
  45 AliITSpList::AliITSpList(Int_t imax,Int_t jmax){
  46     // Standard constructor
  47     // Inputs:
  48     //    none.
  49     // Outputs:
  50     //    none.
  51     // Return:
  52     //    A setup AliITSpList class.
  53
  54     fNi = imax;
  55     fNj = jmax;
  56     fEnteries = 0;
  57     fa  = new TObjArray(fNi*fNj); // elements are zeroed by
  58                                   // TObjArray creator
  59 }
  60 //______________________________________________________________________
  61 AliITSpList::~AliITSpList(){
  62     // Default destructor
  63     // Inputs:
  64     //    none.
  65     // Outputs:
  66     //    none.
  67     // Return:
  68     //    a properly destroyed class
  69
  70     for(Int_t i=0;i<GetMaxIndex();i++) if(fa->At(i)!=0){
  71         delete fa->At(i);
  72         fa->AddAt(0,i); // zero content
  73     } // end for i && if
  74     fNi = 0;
  75     fNj = 0;
  76     delete fa;
  77     fa  = 0;
  78     fEnteries = 0;
  79 }
  80 //______________________________________________________________________
  81 void AliITSpList::ClearMap(){
  82     // Delete all AliITSpListItems and zero TObjArray.
  83     // Inputs:
  84     //    none.
  85     // Outputs:
  86     //    none.
  87     // Return:
  88     //    A zeroed AliITSpList class.
  89
  90     fa->Delete();
  91     /*
  92     for(Int_t i=0;i<GetMaxIndex();i++) if(fa->At(i)!=0){
  93         delete fa->At(i);
  94         fa->AddAt(0,i); // zero content
  95     } // end for i && if
  96     */
  97     fEnteries = 0;
  98 }
  99 //______________________________________________________________________
 100 void AliITSpList::DeleteHit(Int_t i,Int_t j){
 101     // Delete a particular AliITSpListItems and zero TObjArray.
 102     // Inputs:
 103     //    Int_t i   Row number
 104     //    Int_t j   Columns number
 105     // Outputs:
 106     //    none.
 107     // Return:
 108     //    none.
 109     Int_t k = GetIndex(i,j);
 110
 111     if(fa->At(k)!=0){
 112         delete fa->At(k);
 113         fa->AddAt(0,k); // zero content
 114     } // end for i && if
 115     if(k==fEnteries-1) fEnteries--;
 116 }
 117 //______________________________________________________________________
 118 AliITSpList& AliITSpList::operator=(const AliITSpList &source){
 119     // = operator
 120     // Inputs:
 121     //    const AliITSpList &source    A AliITSpList object.
 122     // Outputs:
 123     //    none.
 124     // Return:
 125     //    A copied AliITSpList object.
 126
 127     if(this == &source) return *this;
 128
 129     if(this->fa!=0){ // if this->fa exists delete it first.
 130         for(Int_t i=0;i<GetMaxIndex();i++) if(fa->At(i)!=0){
 131             delete fa->At(i);
 132             fa->AddAt(0,i); // zero content
 133         } // end for i && if
 134         delete this->fa;
 135     } // end if this->fa!=0
 136     this->fNi = source.fNi;
 137     this->fNj = source.fNj;
 138     this->fa = new TObjArray(*(source.fa));
 139     this->fEnteries = source.fEnteries;
 140
 141     return *this;
 142 }
 143 //______________________________________________________________________
 144 AliITSpList::AliITSpList(AliITSpList &source){
 145     // Copy operator
 146     // Inputs:
 147     //    AliITSpList &source   A AliITSpList Object
 148     // Outputs:
 149     //    none.
 150     // Return:
 151     //    A copied AliITSpList object
 152
 153     *this = source;
 154 }
 155 //______________________________________________________________________
 156 void AliITSpList::AddItemTo(Int_t fileIndex, AliITSpListItem *pl) {
 157     // Adds the contents of pl to the list with track number off set given by
 158     // fileIndex.
 159     // Creates the AliITSpListItem if needed.
 160     // Inputs:
 161     //    Int_t fileIndex      track number offset value
 162     //    AliITSpListItem *pl  an AliITSpListItem to be added to this class.
 163     // Outputs:
 164     //    none.
 165     // Return:
 166     //    none.
 167     Int_t index = pl->GetIndex();
 168
 169     if( fa->At( index ) == 0 ) { // most create AliITSpListItem
 170         fa->AddAt(new AliITSpListItem(-2,-1,pl->GetModule(),index,0.0),index);
 171     } // end if
 172
 173     ((AliITSpListItem*)(fa->At(index)))->AddTo( fileIndex,pl);
 174     if(index>=fEnteries) fEnteries = index +1;
 175 }
 176 //______________________________________________________________________
 177 void AliITSpList::AddSignal(Int_t i,Int_t j,Int_t trk,Int_t ht,Int_t mod,
 178                        Double_t signal){
 179     // Adds a Signal value to the TObjArray at i,j. Creates the AliITSpListItem
 180     // if needed.
 181     // Inputs:
 182     //    Int_t i         Row number for this signal
 183     //    Int_t j         Column number for this signal
 184     //    Int_t trk       Track number creating this signal
 185     //    Int_t ht        Hit number creating this signal
 186     //    Int_t mod       The module where this signal is in
 187     //    Double_t signal The signal (ionization)
 188     // Outputs:
 189     //    none.
 190     // Return:
 191     //    none.
 192     Int_t index = GetIndex(i,j);
 193
 194     if(GetpListItem(index)==0){ // most create AliITSpListItem
 195         fa->AddAt(new AliITSpListItem(trk,ht,mod,index,signal),index);
 196     }else{ // AliITSpListItem exists, just add signal to it.
 197         GetpListItem(index)->AddSignal(trk,ht,mod,index,signal);
 198     } // end if
 199     if(index>=fEnteries) fEnteries = index +1;
 200 }
 201 //______________________________________________________________________
 202 void AliITSpList::AddNoise(Int_t i,Int_t j,Int_t mod,Double_t noise){
 203     // Adds a noise value to the TObjArray at i,j. Creates the AliITSpListItem
 204     // if needed.
 205     // Inputs:
 206     //    Int_t i        Row number for this noise
 207     //    Int_t j        Column number for this noise
 208     //    Double_t noise The noise signal value.
 209     // Outputs:
 210     //    none.
 211     // Return:
 212     //    none.
 213     Int_t index = GetIndex(i,j);
 214
 215     if(GetpListItem(index)==0){ // most create AliITSpListItem
 216         fa->AddAt(new AliITSpListItem(mod,index,noise),index);
 217     }else{ // AliITSpListItem exists, just add signal to it.
 218         GetpListItem(index)->AddNoise(mod,index,noise);
 219     } // end if
 220     if(index>=fEnteries) fEnteries = index +1;
 221 }
 222 //______________________________________________________________________
 223
 224 ClassImp(AliITSpListItem)
 225 //______________________________________________________________________
 226 AliITSpListItem::AliITSpListItem(){
 227     // Default constructor
 228     // Inputs:
 229     //    none.
 230     // Outputs:
 231     //    none.
 232     // Return:
 233     //    A zeroed/empty AliITSpListItem class.
 234
 235     fmodule = -1;
 236     findex  = -1;
 237     for(Int_t i=0;i<this->fkSize;i++){
 238         this->fTrack[i]  = -2;
 239         this->fHits[i]   = -1;
 240         this->fSignal[i] = 0.0;
 241     } // end if i
 242     fTsignal = 0.0;
 243     fNoise   = 0.0;
 244     fSignalAfterElect = 0.0;
 245 }
 246 //______________________________________________________________________
 247 AliITSpListItem::AliITSpListItem(Int_t module,Int_t index,Double_t noise){
 248     // Standard noise constructor
 249     // Inputs:
 250     //    Int_t module   The module where this noise occurred
 251     //    Int_t index    The cell index where this noise occurred
 252     //    Double_t noise The value of the noise.
 253     // Outputs:
 254     //    none.
 255     // Return:
 256     //    A setup and noise filled AliITSpListItem class.
 257
 258     this->fmodule    = module;
 259     this->findex     = index;
 260     for(Int_t i=0;i<this->fkSize;i++){
 261         this->fTrack[i]  = -2;
 262         this->fSignal[i] = 0.0;
 263         this->fHits[i]   = -1;
 264     } // end if i
 265     this->fTsignal = 0.0;
 266     this->fSignalAfterElect = 0.0;
 267     this->fNoise   = noise;
 268 }
 269 //______________________________________________________________________
 270 AliITSpListItem::AliITSpListItem(Int_t track,Int_t hit,Int_t module,
 271                                Int_t index,Double_t signal){
 272     // Standard signal constructor
 273     // Inputs:
 274     //    Int_t track     The track number which produced this signal
 275     //    Int_t hit       The hit number which produced this signal
 276     //    Int_t module    The module where this signal occurred
 277     //    Int_t index     The cell index where this signal occurred
 278     //    Double_t signal The value of the signal (ionization)
 279     // Outputs:
 280     //    none.
 281     // Return:
 282     //    A setup and signal filled  AliITSpListItem class.
 283
 284     this->fmodule    = module;
 285     this->findex     = index;
 286     this->fTrack[0]  = track;
 287     this->fHits[0]   = hit;
 288     this->fSignal[0] = signal;
 289     for(Int_t i=1;i<this->fkSize;i++){
 290         this->fTrack[i]  = -2;
 291         this->fSignal[i] = 0.0;
 292         this->fHits[i]   = -1;
 293     } // end if i
 294     this->fTsignal = signal;
 295     this->fNoise   = 0.0;
 296     this->fSignalAfterElect   = 0.0;
 297 }
 298 //______________________________________________________________________
 299 AliITSpListItem::~AliITSpListItem(){
 300     // Destructor
 301     // Inputs:
 302     //    none.
 303     // Outputs:
 304     //    none.
 305     // Return:
 306     //    A properly destroyed AliITSpListItem class.
 307
 308     if(!fTrack)  delete [] fTrack;
 309     if(!fHits)   delete [] fHits;
 310     if(!fSignal) delete [] fSignal;
 311 }
 312 //______________________________________________________________________
 313 AliITSpListItem& AliITSpListItem::operator=(const AliITSpListItem &source){
 314     // = operator
 315     // Inputs:
 316     //    AliITSpListItem &source   A AliITSpListItem Object
 317     // Outputs:
 318     //    none.
 319     // Return:
 320     //    A copied AliITSpListItem object
 321
 322     if(this == &source) return *this;
 323
 324     this->fmodule = source.fmodule;
 325     this->findex  = source.findex;
 326     for(Int_t i=0;i<this->fkSize;i++){
 327         this->fTrack[i]  = source.fTrack[i];
 328         this->fSignal[i] = source.fSignal[i];
 329         this->fHits[i]   = source.fHits[i];
 330     } // end if i
 331     this->fTsignal = source.fTsignal;
 332     this->fNoise   = source.fNoise;
 333     this->fSignalAfterElect   = source.fSignalAfterElect;
 334
 335     return *this;
 336 }
 337 //______________________________________________________________________
 338 AliITSpListItem::AliITSpListItem(AliITSpListItem &source){
 339     // Copy operator
 340     // Inputs:
 341     //    AliITSpListItem &source   A AliITSpListItem Object
 342     // Outputs:
 343     //    none.
 344     // Return:
 345     //    A copied AliITSpListItem object
 346
 347     *this = source;
 348 }
 349 //______________________________________________________________________
 350 void AliITSpListItem::AddSignal(Int_t track,Int_t hit,Int_t module,
 351                                Int_t index,Double_t signal){
 352     // Adds this track number and signal to the pList and orders them
 353     // Inputs:
 354     //    Int_t track     The track number which produced this signal
 355     //    Int_t hit       The hit number which produced this signal
 356     //    Int_t module    The module where this signal occurred
 357     //    Int_t index     The cell index where this signal occurred
 358     //    Double_t signal The value of the signal (ionization)
 359     // Outputs:
 360     //    none.
 361     // Return:
 362     //    none.
 363     Int_t    i,j,trk,hts;
 364     Double_t sig;
 365     Bool_t   flg=kFALSE;
 366
 367     if(findex!=index || fmodule!=module)
 368         Warning("AddSignal","index=%d != findex=%d or module=%d != fmodule=%d",
 369                  index,findex,module,fmodule);
 370     fTsignal += signal; // Keep track of sum signal.
 371
 372     for(i=0;i<fkSize;i++) if( track==fTrack[i] && hit==fHits[i] ){
 373         fSignal[i] += signal;
 374         flg = kTRUE;
 375     } // end for i & if.
 376     if(flg){ // resort arrays.
 377         for(i=1;i<fkSize;i++){
 378             j = i;
 379             while(j>0 && fSignal[j]>fSignal[j-1]){
 380                 trk = fTrack[j-1];
 381                 hts = fHits[j-1];
 382                 sig = fSignal[j-1];
 383                 fTrack[j-1]  = fTrack[j];
 384                 fHits[j-1]   = fHits[j];
 385                 fSignal[j-1] = fSignal[j];
 386                 fTrack[j]  = trk;
 387                 fHits[j]   = hts;
 388                 fSignal[j] = sig;
 389                 j--;
 390             } // end while
 391         } // end if i
 392         return;
 393     } // end if added to existing and resorted array
 394
 395     // new entry add it in order.
 396     // if this signal is <= smallest then don't add it.
 397     if(signal <= fSignal[fkSize-1]) return;
 398     for(i=fkSize-2;i>=0;i--){
 399         if(signal > fSignal[i]){
 400             fSignal[i+1] = fSignal[i];
 401             fTrack[i+1]  = fTrack[i];
 402             fHits[i+1]   = fHits[i];
 403         }else{
 404             fSignal[i+1] = signal;
 405             fTrack[i+1]  = track;
 406             fHits[i+1]   = hit;
 407             return; // put it in the right place, now exit.
 408         } //  end if
 409     } // end if; end for i
 410     // Still haven't found the right place. Must be at top of list.
 411     fSignal[0] = signal;
 412     fTrack[0]  = track;
 413     fHits[0]   = hit;
 414     return;
 415 }
 416 //______________________________________________________________________
 417 void AliITSpListItem::AddNoise(Int_t module,Int_t index,Double_t noise){
 418     // Adds noise to this existing list.
 419     // Inputs:
 420     //    Int_t module   The module where this noise occurred
 421     //    Int_t index    The cell index where this noise occurred
 422     //    Double_t noise The value of the noise.
 423     // Outputs:
 424     //    none.
 425     // Return:
 426     //    none.
 427
 428     if(findex!=index || fmodule!=module)
 429         Warning("AddNoise","index=%d != findex=%d or module=%d != fmodule=%d",
 430             index,findex,module,fmodule);
 431     fNoise += noise; // Keep track of sum signal.
 432 }
 433 //______________________________________________________________________
 434 void AliITSpListItem::AddSignalAfterElect(Int_t module,Int_t index,Double_t signal){
 435     // Adds signal after electronics to this existing list.
 436     // Inputs:
 437     //    Int_t module   The module where this noise occurred
 438     //    Int_t index    The cell index where this noise occurred
 439     //    Double_t signal The value of the signal.
 440     // Outputs:
 441     //    none.
 442     // Return:
 443     //    none.
 444
 445     if(findex!=index || fmodule!=module)
 446         Warning("AddSignalAfterElect","index=%d != findex=%d or module=%d "
 447                 "!= fmodule=%d",index,findex,module,fmodule);
 448     fSignalAfterElect += signal; // Keep track of sum signal.
 449 }
 450 //______________________________________________________________________
 451 void AliITSpListItem::Add(AliITSpListItem *pl){
 452     // Adds the contents of pl to this
 453     // pl could come from different module and index
 454     // Inputs:
 455     //    AliITSpListItem *pl  an AliITSpListItem to be added to this class.
 456     // Outputs:
 457     //    none.
 458     // Return:
 459     //    none.
 460     Int_t i;
 461     Double_t sig  = 0.0;
 462     Double_t sigT = 0.0;
 463
 464     for(i=0;i<pl->GetNsignals();i++){
 465         sig = pl->GetSignal(i);
 466         if( sig <= 0.0 ) break; // no more signals
 467         AddSignal(pl->GetTrack(i),pl->GetHit(i),fmodule,findex,sig);
 468         sigT += sig;
 469     } // end for i
 470     fTsignal += (pl->fTsignal - sigT);
 471     fNoise   += pl->fNoise;
 472     return;
 473 }
 474 //______________________________________________________________________
 475 void AliITSpListItem::AddTo(Int_t fileIndex,AliITSpListItem *pl){
 476     // Adds the contents of pl to this with track number off set given by
 477     // fileIndex.
 478     // Inputs:
 479     //    Int_t fileIndex      track number offset value
 480     //    AliITSpListItem *pl  an AliITSpListItem to be added to this class.
 481     // Outputs:
 482     //    none.
 483     // Return:
 484     //    none.
 485     Int_t i,trk;
 486     Double_t sig  = 0.0;
 487
 488     Int_t module = pl->GetModule();
 489     Int_t index  = pl->GetIndex();
 490     for(i=0;i<pl->GetNsignals();i++){
 491         sig = pl->GetSignal(i);
 492         if( sig <= 0.0 ) break; // no more signals
 493         trk = pl->GetTrack(i);
 494         trk += fileIndex;
 495         AddSignal(trk,pl->GetHit(i),module,index,sig);
 496     } // end for i
 497     fSignalAfterElect += (pl->fSignalAfterElect + pl->fNoise - fNoise);
 498     fNoise = pl->fNoise;
 499     return;
 500 }
 501 //______________________________________________________________________
 502 Int_t AliITSpListItem::ShiftIndex(Int_t in,Int_t trk){
 503     // Shift an index number to occupy the upper four bits. No longer used.
 504     // Inputs:
 505     //    Int_t in   The file number
 506     //    Int_t trk  The track number
 507     // Outputs:
 508     //    none.
 509     // Return:
 510     //    Int_t The track number with the file number in the upper bits.
 511     Int_t si = sizeof(Int_t) * 8;
 512     UInt_t uin,utrk; // use UInt_t to avoid interger overflow-> goes negative.
 513
 514     uin = in;
 515     utrk = trk;
 516     for(Int_t i=0;i<si-4;i++) uin *= 2;
 517     uin += utrk;
 518     in = uin;
 519     return in;
 520 }
 521 //______________________________________________________________________
 522 void AliITSpListItem::Print(ostream *os){
 523     //Standard output format for this class
 524     // Inputs:
 525     //    ostream *os  The output stream
 526     // Outputs:
 527     //    none.
 528     // Return:
 529     //    none.
 530     Int_t i;
 531
 532     *os << fmodule <<","<<findex<<",";
 533     *os << fkSize <<",";
 534     for(i=0;i<fkSize;i++) *os << fTrack[i] <<",";
 535     for(i=0;i<fkSize;i++) *os << fHits[i] <<",";
 536     for(i=0;i<fkSize;i++) *os << fSignal[i] <<",";
 537     *os << fTsignal <<","<< fNoise << "," << fSignalAfterElect;
 538 }
 539 //______________________________________________________________________
 540 void AliITSpListItem::Read(istream *is){
 541     // Standard output streaming function.
 542     // Inputs:
 543     //    istream *is The input stream
 544     // Outputs:
 545     //    none.
 546     // Return:
 547     //    none.
 548     Int_t i,iss;
 549
 550     *is >> fmodule >> findex;
 551     *is >> iss; // read in fkSize
 552     for(i=0;i<fkSize&&i<iss;i++) *is >> fTrack[i];
 553     for(i=0;i<fkSize&&i<iss;i++) *is >> fHits[i];
 554     for(i=0;i<fkSize&&i<iss;i++) *is >> fSignal[i];
 555     *is >> fTsignal >> fNoise >> fSignalAfterElect;
 556 }
 557 //______________________________________________________________________
 558 ostream &operator<<(ostream &os,AliITSpListItem &source){
 559     // Standard output streaming function.
 560     // Inputs:
 561     //    ostream &os             The output stream
 562     //    AliITSpListItem &source The AliITSpListItem object to be written out.
 563     // Outputs:
 564     //    none.
 565     // Return:
 566     //    ostream  The output stream
 567
 568     source.Print(&os);
 569     return os;
 570 }
 571 //______________________________________________________________________
 572 istream &operator>>(istream &os,AliITSpListItem &source){
 573     // Standard output streaming function.
 574     // Inputs:
 575     //    istream os              The input stream
 576     //    AliITSpListItem &source The AliITSpListItem object to be inputted
 577     // Outputs:
 578     //    none.
 579     // Return:
 580     //    istream The input stream.
 581
 582     source.Read(&os);
 583     return os;
 584 }
 585