8a79db915fd789c5b3b337ff6264f45d6196bf4f
[u/mrichter/AliRoot.git] / 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