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     this->fmodule = 0;
 309     this->findex  = 0;
 310     for(Int_t i=0;i<=this->GetNsignals();i++){
 311         this->fTrack[i]  = 0;
 312         this->fSignal[i] = 0.0;
 313         this->fHits[i]   = 0;
 314     } // end if i
 315     this->fTsignal = 0.0;
 316     this->fNoise   = 0.0;
 317 */
 318 }
 319 //______________________________________________________________________
 320 AliITSpListItem& AliITSpListItem::operator=(const AliITSpListItem &source){
 321     // = operator
 322     // Inputs:
 323     //    AliITSpListItem &source   A AliITSpListItem Object
 324     // Outputs:
 325     //    none.
 326     // Return:
 327     //    A copied AliITSpListItem object
 328
 329     if(this == &source) return *this;
 330
 331     this->fmodule = source.fmodule;
 332     this->findex  = source.findex;
 333     for(Int_t i=0;i<this->fkSize;i++){
 334         this->fTrack[i]  = source.fTrack[i];
 335         this->fSignal[i] = source.fSignal[i];
 336         this->fHits[i]   = source.fHits[i];
 337     } // end if i
 338     this->fTsignal = source.fTsignal;
 339     this->fNoise   = source.fNoise;
 340     this->fSignalAfterElect   = source.fSignalAfterElect;
 341
 342     return *this;
 343 }
 344 //______________________________________________________________________
 345 AliITSpListItem::AliITSpListItem(AliITSpListItem &source){
 346     // Copy operator
 347     // Inputs:
 348     //    AliITSpListItem &source   A AliITSpListItem Object
 349     // Outputs:
 350     //    none.
 351     // Return:
 352     //    A copied AliITSpListItem object
 353
 354     *this = source;
 355 }
 356 //______________________________________________________________________
 357 void AliITSpListItem::AddSignal(Int_t track,Int_t hit,Int_t module,
 358                                Int_t index,Double_t signal){
 359     // Adds this track number and signal to the pList and orders them
 360     // Inputs:
 361     //    Int_t track     The track number which produced this signal
 362     //    Int_t hit       The hit number which produced this signal
 363     //    Int_t module    The module where this signal occurred
 364     //    Int_t index     The cell index where this signal occurred
 365     //    Double_t signal The value of the signal (ionization)
 366     // Outputs:
 367     //    none.
 368     // Return:
 369     //    none.
 370     Int_t    i,j,trk,hts;
 371     Double_t sig;
 372     Bool_t   flg=kFALSE;
 373
 374     if(findex!=index || fmodule!=module)
 375         Warning("AddSignal","index=%d != findex=%d or module=%d != fmodule=%d",
 376                  index,findex,module,fmodule);
 377     fTsignal += signal; // Keep track of sum signal.
 378
 379     for(i=0;i<fkSize;i++) if( track==fTrack[i] && hit==fHits[i] ){
 380         fSignal[i] += signal;
 381         flg = kTRUE;
 382     } // end for i & if.
 383     if(flg){ // resort arrays.
 384         for(i=1;i<fkSize;i++){
 385             j = i;
 386             while(j>0 && fSignal[j]>fSignal[j-1]){
 387                 trk = fTrack[j-1];
 388                 hts = fHits[j-1];
 389                 sig = fSignal[j-1];
 390                 fTrack[j-1]  = fTrack[j];
 391                 fHits[j-1]   = fHits[j];
 392                 fSignal[j-1] = fSignal[j];
 393                 fTrack[j]  = trk;
 394                 fHits[j]   = hts;
 395                 fSignal[j] = sig;
 396                 j--;
 397             } // end while
 398         } // end if i
 399         return;
 400     } // end if added to existing and resorted array
 401
 402     // new entry add it in order.
 403     // if this signal is <= smallest then don't add it.
 404     if(signal <= fSignal[fkSize-1]) return;
 405     for(i=fkSize-2;i>=0;i--){
 406         if(signal > fSignal[i]){
 407             fSignal[i+1] = fSignal[i];
 408             fTrack[i+1]  = fTrack[i];
 409             fHits[i+1]   = fHits[i];
 410         }else{
 411             fSignal[i+1] = signal;
 412             fTrack[i+1]  = track;
 413             fHits[i+1]   = hit;
 414             return; // put it in the right place, now exit.
 415         } //  end if
 416     } // end if; end for i
 417     // Still haven't found the right place. Must be at top of list.
 418     fSignal[0] = signal;
 419     fTrack[0]  = track;
 420     fHits[0]   = hit;
 421     return;
 422 }
 423 //______________________________________________________________________
 424 void AliITSpListItem::AddNoise(Int_t module,Int_t index,Double_t noise){
 425     // Adds noise to this existing list.
 426     // Inputs:
 427     //    Int_t module   The module where this noise occurred
 428     //    Int_t index    The cell index where this noise occurred
 429     //    Double_t noise The value of the noise.
 430     // Outputs:
 431     //    none.
 432     // Return:
 433     //    none.
 434
 435     if(findex!=index || fmodule!=module)
 436         Warning("AddNoise","index=%d != findex=%d or module=%d != fmodule=%d",
 437             index,findex,module,fmodule);
 438     fNoise += noise; // Keep track of sum signal.
 439 }
 440 //______________________________________________________________________
 441 void AliITSpListItem::AddSignalAfterElect(Int_t module,Int_t index,Double_t signal){
 442     // Adds signal after electronics to this existing list.
 443     // Inputs:
 444     //    Int_t module   The module where this noise occurred
 445     //    Int_t index    The cell index where this noise occurred
 446     //    Double_t signal The value of the signal.
 447     // Outputs:
 448     //    none.
 449     // Return:
 450     //    none.
 451
 452     if(findex!=index || fmodule!=module)
 453         Warning("AddSignalAfterElect","index=%d != findex=%d or module=%d "
 454                 "!= fmodule=%d",index,findex,module,fmodule);
 455     fSignalAfterElect += signal; // Keep track of sum signal.
 456 }
 457 //______________________________________________________________________
 458 void AliITSpListItem::Add(AliITSpListItem *pl){
 459     // Adds the contents of pl to this
 460     // pl could come from different module and index
 461     // Inputs:
 462     //    AliITSpListItem *pl  an AliITSpListItem to be added to this class.
 463     // Outputs:
 464     //    none.
 465     // Return:
 466     //    none.
 467     Int_t i;
 468     Double_t sig  = 0.0;
 469     Double_t sigT = 0.0;
 470
 471     for(i=0;i<pl->GetNsignals();i++){
 472         sig = pl->GetSignal(i);
 473         if( sig <= 0.0 ) break; // no more signals
 474         AddSignal(pl->GetTrack(i),pl->GetHit(i),fmodule,findex,sig);
 475         sigT += sig;
 476     } // end for i
 477     fTsignal += (pl->fTsignal - sigT);
 478     fNoise   += pl->fNoise;
 479     return;
 480 }
 481 //______________________________________________________________________
 482 void AliITSpListItem::AddTo(Int_t fileIndex,AliITSpListItem *pl){
 483     // Adds the contents of pl to this with track number off set given by
 484     // fileIndex.
 485     // Inputs:
 486     //    Int_t fileIndex      track number offset value
 487     //    AliITSpListItem *pl  an AliITSpListItem to be added to this class.
 488     // Outputs:
 489     //    none.
 490     // Return:
 491     //    none.
 492     Int_t i,trk;
 493     Double_t sig  = 0.0;
 494
 495     Int_t module = pl->GetModule();
 496     Int_t index  = pl->GetIndex();
 497     for(i=0;i<pl->GetNsignals();i++){
 498         sig = pl->GetSignal(i);
 499         if( sig <= 0.0 ) break; // no more signals
 500         trk = pl->GetTrack(i);
 501         trk += fileIndex;
 502         AddSignal(trk,pl->GetHit(i),module,index,sig);
 503     } // end for i
 504     fSignalAfterElect += (pl->fSignalAfterElect + pl->fNoise - fNoise);
 505     fNoise = pl->fNoise;
 506     return;
 507 }
 508 //______________________________________________________________________
 509 Int_t AliITSpListItem::ShiftIndex(Int_t in,Int_t trk){
 510     // Shift an index number to occupy the upper four bits. No longer used.
 511     // Inputs:
 512     //    Int_t in   The file number
 513     //    Int_t trk  The track number
 514     // Outputs:
 515     //    none.
 516     // Return:
 517     //    Int_t The track number with the file number in the upper bits.
 518     Int_t si = sizeof(Int_t) * 8;
 519     UInt_t uin,utrk; // use UInt_t to avoid interger overflow-> goes negative.
 520
 521     uin = in;
 522     utrk = trk;
 523     for(Int_t i=0;i<si-4;i++) uin *= 2;
 524     uin += utrk;
 525     in = uin;
 526     return in;
 527 }
 528 //______________________________________________________________________
 529 void AliITSpListItem::Print(ostream *os){
 530     //Standard output format for this class
 531     // Inputs:
 532     //    ostream *os  The output stream
 533     // Outputs:
 534     //    none.
 535     // Return:
 536     //    none.
 537     Int_t i;
 538
 539     *os << fmodule <<","<<findex<<",";
 540     *os << fkSize <<",";
 541     for(i=0;i<fkSize;i++) *os << fTrack[i] <<",";
 542     for(i=0;i<fkSize;i++) *os << fHits[i] <<",";
 543     for(i=0;i<fkSize;i++) *os << fSignal[i] <<",";
 544     *os << fTsignal <<","<< fNoise << "," << fSignalAfterElect;
 545 }
 546 //______________________________________________________________________
 547 void AliITSpListItem::Read(istream *is){
 548     // Standard output streaming function.
 549     // Inputs:
 550     //    istream *is The input stream
 551     // Outputs:
 552     //    none.
 553     // Return:
 554     //    none.
 555     Int_t i,iss;
 556
 557     *is >> fmodule >> findex;
 558     *is >> iss; // read in fkSize
 559     for(i=0;i<fkSize&&i<iss;i++) *is >> fTrack[i];
 560     for(i=0;i<fkSize&&i<iss;i++) *is >> fHits[i];
 561     for(i=0;i<fkSize&&i<iss;i++) *is >> fSignal[i];
 562     *is >> fTsignal >> fNoise >> fSignalAfterElect;
 563 }
 564 //______________________________________________________________________
 565 ostream &operator<<(ostream &os,AliITSpListItem &source){
 566     // Standard output streaming function.
 567     // Inputs:
 568     //    ostream &os             The output stream
 569     //    AliITSpListItem &source The AliITSpListItem object to be written out.
 570     // Outputs:
 571     //    none.
 572     // Return:
 573     //    ostream  The output stream
 574
 575     source.Print(&os);
 576     return os;
 577 }
 578 //______________________________________________________________________
 579 istream &operator>>(istream &os,AliITSpListItem &source){
 580     // Standard output streaming function.
 581     // Inputs:
 582     //    istream os              The input stream
 583     //    AliITSpListItem &source The AliITSpListItem object to be inputted
 584     // Outputs:
 585     //    none.
 586     // Return:
 587     //    istream The input stream.
 588
 589     source.Read(&os);
 590     return os;
 591 }
 592