Added functions needed for SDD new SDigits/Digits (Add and fSigmaAfterElect).
[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     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