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