Transition to NewIO
[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
16 /* $Id$ */
17
18 #include <stdio.h>
19 #include <stdlib.h>
20 #include <Riostream.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     Int_t i;
319
320     if(this == &source) return *this;
321
322     this->fmodule = source.fmodule;
323     this->findex  = source.findex;
324     for(i=0;i<this->fkSize;i++){
325         this->fTrack[i]  = source.fTrack[i];
326         this->fSignal[i] = source.fSignal[i];
327         this->fHits[i]   = source.fHits[i];
328     } // end if i
329     this->fTsignal = source.fTsignal;
330     this->fNoise   = source.fNoise;
331     this->fSignalAfterElect   = source.fSignalAfterElect;
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     //cout << "track="<<track<<endl;
374     if(flg){ // resort arrays.  
375         for(i=1;i<fkSize;i++){
376             j = i;
377             while(j>0 && fSignal[j]>fSignal[j-1]){
378                 trk = fTrack[j-1];
379                 hts = fHits[j-1];
380                 sig = fSignal[j-1];
381                 fTrack[j-1]  = fTrack[j];
382                 fHits[j-1]   = fHits[j];
383                 fSignal[j-1] = fSignal[j];                
384                 fTrack[j]  = trk;
385                 fHits[j]   = hts;
386                 fSignal[j] = sig;
387                 //cout << "#fTrack["<<j-1<<"]="<<fTrack[j-1]<< " fTrack["<<
388                 // j<<"]="<<fTrack[j]<<endl;
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         //cout << "$fTrack["<<i+1<<"]="<<fTrack[i+1]<< " fTrack["<<i<<"]="
410         //<<fTrack[i]<< " fHits["<<i+1<<"]="<<fHits[i+1]<< " fHits["<<i<<"]="
411         //<<fHits[i]<< " fSignal["<<i+1<<"]="<<fSignal[i+1]<< " fSignal["<<i
412         //<<"]="<<fSignal[i]<<endl;
413     } // end if; end for i
414     // Still haven't found the right place. Must be at top of list.
415     fSignal[0] = signal;
416     fTrack[0]  = track;
417     fHits[0]   = hit;
418     //cout << "$fTrack["<<0<<"]="<<fTrack[0]<<" fHits["<<0<<"]="<<fHits[0]
419     //<<" fSignal["<<0<<"]="<<fSignal[0]<<endl;
420     return;
421 }
422 //______________________________________________________________________
423 void AliITSpListItem::AddNoise(Int_t module,Int_t index,Double_t noise){
424     // Adds noise to this existing list.
425     // Inputs:
426     //    Int_t module   The module where this noise occurred
427     //    Int_t index    The cell index where this noise occurred
428     //    Double_t noise The value of the noise.
429     // Outputs:
430     //    none.
431     // Return:
432     //    none.
433
434     if(findex!=index || fmodule!=module) 
435         Warning("AddNoise","index=%d != findex=%d or module=%d != fmodule=%d",
436             index,findex,module,fmodule);
437     fNoise += noise; // Keep track of sum signal.
438 }
439 //______________________________________________________________________
440 void AliITSpListItem::AddSignalAfterElect(Int_t module,Int_t index,Double_t signal){
441     // Adds signal after electronics to this existing list.
442     // Inputs:
443     //    Int_t module   The module where this noise occurred
444     //    Int_t index    The cell index where this noise occurred
445     //    Double_t signal The value of the signal.
446     // Outputs:
447     //    none.
448     // Return:
449     //    none.
450
451     if(findex!=index || fmodule!=module) 
452         Warning("AddSignalAfterElect","index=%d != findex=%d or module=%d "
453                 "!= fmodule=%d",index,findex,module,fmodule);
454     fSignalAfterElect += signal; // Keep track of sum signal.
455 }
456 //______________________________________________________________________
457 void AliITSpListItem::Add(AliITSpListItem *pl){
458     // Adds the contents of pl to this
459     // pl could come from different module and index 
460     // Inputs:
461     //    AliITSpListItem *pl  an AliITSpListItem to be added to this class.
462     // Outputs:
463     //    none.
464     // Return:
465     //    none.
466     Int_t i;
467     Double_t sig  = 0.0;
468     Double_t sigT = 0.0;
469
470     for(i=0;i<pl->GetNsignals();i++){
471         sig = pl->GetSignal(i); 
472         if( sig <= 0.0 ) break; // no more signals
473         AddSignal(pl->GetTrack(i),pl->GetHit(i),fmodule,findex,sig);
474         sigT += sig;
475     } // end for i
476     fTsignal += (pl->fTsignal - sigT);
477     fNoise   += pl->fNoise;
478     return;
479 }
480 //______________________________________________________________________
481 void AliITSpListItem::AddTo(Int_t fileIndex,AliITSpListItem *pl){
482     // Adds the contents of pl to this with track number off set given by
483     // fileIndex.
484     // Inputs:
485     //    Int_t fileIndex      track number offset value
486     //    AliITSpListItem *pl  an AliITSpListItem to be added to this class.
487     // Outputs:
488     //    none.
489     // Return:
490     //    none.
491     Int_t i,trk;
492     Double_t sig  = 0.0;
493
494     Int_t module = pl->GetModule();
495     Int_t index  = pl->GetIndex();
496     for(i=0;i<pl->GetNsignals();i++){
497         sig = pl->GetSignal(i); 
498         if( sig <= 0.0 ) break; // no more signals
499         trk = pl->GetTrack(i);
500         trk += fileIndex; 
501         AddSignal(trk,pl->GetHit(i),module,index,sig);
502     } // end for i
503     fSignalAfterElect += (pl->fSignalAfterElect + pl->fNoise - fNoise);
504     fNoise = pl->fNoise;
505     return;
506 }
507 //______________________________________________________________________
508 Int_t AliITSpListItem::ShiftIndex(Int_t in,Int_t trk){
509     // Shift an index number to occupy the upper four bits. No longer used.
510     // Inputs:
511     //    Int_t in   The file number
512     //    Int_t trk  The track number
513     // Outputs:
514     //    none.
515     // Return:
516     //    Int_t The track number with the file number in the upper bits.
517     Int_t si = sizeof(Int_t) * 8;
518     UInt_t uin,utrk; // use UInt_t to avoid interger overflow-> goes negative.
519
520     uin = in;
521     utrk = trk;
522     for(Int_t i=0;i<si-4;i++) uin *= 2;
523     uin += utrk;
524     in = uin;
525     return in;
526 }
527 //______________________________________________________________________
528 void AliITSpListItem::Print(ostream *os){
529     //Standard output format for this class
530     // Inputs:
531     //    ostream *os  The output stream
532     // Outputs:
533     //    none.
534     // Return:
535     //    none.
536     Int_t i;
537
538     *os << fmodule <<","<<findex<<",";
539     *os << fkSize <<",";
540     for(i=0;i<fkSize;i++) *os << fTrack[i] <<",";
541     for(i=0;i<fkSize;i++) *os << fHits[i] <<",";
542     for(i=0;i<fkSize;i++) *os << fSignal[i] <<",";
543     *os << fTsignal <<","<< fNoise << "," << fSignalAfterElect;
544 }
545 //______________________________________________________________________
546 void AliITSpListItem::Read(istream *is){
547     // Standard output streaming function.
548     // Inputs:
549     //    istream *is The input stream
550     // Outputs:
551     //    none.
552     // Return:
553     //    none.
554     Int_t i,iss;
555
556     *is >> fmodule >> findex;
557     *is >> iss; // read in fkSize
558     for(i=0;i<fkSize&&i<iss;i++) *is >> fTrack[i];
559     for(i=0;i<fkSize&&i<iss;i++) *is >> fHits[i];
560     for(i=0;i<fkSize&&i<iss;i++) *is >> fSignal[i];
561     *is >> fTsignal >> fNoise >> fSignalAfterElect;
562 }
563 //______________________________________________________________________
564 ostream &operator<<(ostream &os,AliITSpListItem &source){
565     // Standard output streaming function.
566     // Inputs:
567     //    ostream &os             The output stream
568     //    AliITSpListItem &source The AliITSpListItem object to be written out.
569     // Outputs:
570     //    none.
571     // Return:
572     //    ostream  The output stream
573
574     source.Print(&os);
575     return os;
576 }
577 //______________________________________________________________________
578 istream &operator>>(istream &os,AliITSpListItem &source){
579     // Standard output streaming function.
580     // Inputs:
581     //    istream os              The input stream
582     //    AliITSpListItem &source The AliITSpListItem object to be inputted
583     // Outputs:
584     //    none.
585     // Return:
586     //    istream The input stream.
587
588     source.Read(&os);
589     return os;
590 }
591