Updates for the ROOT trunk
[u/mrichter/AliRoot.git] / PHOS / AliPHOSDATreeEvent.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 // --
18 // --
19 // Implementation for TTree output in PHOS DA
20 // for calibrating energy by pi0 and MIP.
21 // --
22 // -- Author: Hisayuki Torii (Hiroshima Univ.)
23 // --
24
25 #include <iostream>
26 #include "AliPHOSDATreeEvent.h"
27 ClassImp(AliPHOSDATreeEvent)
28 //------------------------------------------------------------------------
29 AliPHOSDATreeEvent::AliPHOSDATreeEvent(const AliPHOSDATreeEvent& evt)
30 : fTime(0),
31   fNDigits(0),
32   fDigits(0),
33   fNClusters(0),
34   fClusters(0)
35 {
36   // Copy Constructor
37
38   fNDigits = evt.fNDigits;
39   if( fNDigits > 0 ){
40     fDigits = new AliPHOSDATreeDigit[fNDigits];
41     int ndigits = fNDigits;
42     while( ndigits-- ){
43       fDigits[ndigits] = evt.fDigits[ndigits];
44     }
45   } else {
46     fDigits = 0;
47   }
48   //
49   fNClusters = evt.fNClusters;
50   if( fNClusters > 0 ){
51     fClusters = new AliPHOSDATreeCluster[fNClusters];
52     int nclusters = fNClusters;
53     while( nclusters-- ){
54       fClusters[nclusters] = evt.fClusters[nclusters];
55     }
56   } else {
57     fClusters = 0;
58   }
59 }
60 //------------------------------------------------------------------------
61 AliPHOSDATreeEvent& AliPHOSDATreeEvent::operator=(const AliPHOSDATreeEvent& evt){
62   // Copy Operator
63
64   if (this != &evt) {
65     if( fNDigits > 0 ) delete[] fDigits;
66     fNDigits = evt.fNDigits;
67     if( fNDigits > 0 ){
68       fDigits = new AliPHOSDATreeDigit[fNDigits];
69       int ndigits = fNDigits;
70       while( ndigits-- ){
71         fDigits[ndigits] = evt.fDigits[ndigits];
72       }
73     } else {
74       fDigits = 0;
75     }
76     //
77     if( fNClusters > 0 ) delete[] fClusters;
78     fNClusters = evt.fNClusters;
79     if( fNClusters > 0 ){
80       fClusters = new AliPHOSDATreeCluster[fNClusters];
81       int nclusters = fNClusters;
82       while( nclusters-- ){
83         fClusters[nclusters] = evt.fClusters[nclusters];
84       }
85     } else {
86       fClusters = 0;
87     }
88   }
89   return *this;
90 }
91 //------------------------------------------------------------------------
92 bool AliPHOSDATreeEvent::Fill(float energy,int row,int col){
93   // Fill new digit information
94
95   AliPHOSDATreeDigit digit(energy,row,col);
96   return Fill(digit);
97 }
98 //------------------------------------------------------------------------
99 bool AliPHOSDATreeEvent::Fill(AliPHOSDATreeDigit& digit){
100   // Fill new digit information
101
102   AliPHOSDATreeDigit* newDigits = new AliPHOSDATreeDigit[fNDigits+1];
103   int ndigits = fNDigits;
104   newDigits[ndigits] = digit;
105   while( ndigits-- ){
106     newDigits[ndigits] = fDigits[ndigits];
107   }
108   if( fNDigits>0 ) delete[] fDigits;
109   fDigits = newDigits;
110   fNDigits++;
111   return true;
112 }
113 //------------------------------------------------------------------------
114 bool AliPHOSDATreeEvent::Clusterize(AliPHOSDATreeDigit& digit){
115   //Input digit information into clustering
116
117   bool status = false;
118   int nclusters = fNClusters;
119   while( nclusters-- && !status ){
120     if( fClusters[nclusters].IsNeighbor(digit) ){
121       status = fClusters[nclusters].Append(digit);
122     }
123   }
124   //std::cout<<" DEBUGDEBUG:: status = "<<status<<" fNClusters="<<fNClusters<<std::endl;
125   if( !status ){
126     AliPHOSDATreeCluster* newClusters = new AliPHOSDATreeCluster[fNClusters+1];
127     nclusters = fNClusters;
128     status = newClusters[nclusters].Append(digit);
129     while( nclusters-- ){
130       newClusters[nclusters] = fClusters[nclusters];
131     }
132     if( fNClusters>0 ) delete[] fClusters;
133     fClusters = newClusters;
134     fNClusters++;
135   }
136   return status;
137 }
138 //------------------------------------------------------------------------
139 bool AliPHOSDATreeEvent::ExecuteClustering(){
140   // Run clustering algorithm.
141   // With the filled digit information
142   //
143
144   // Loop over all digit information
145   if( fNDigits <= 0 ) return true;
146   bool status = true;
147   int ndigits = fNDigits;
148   while( ndigits-- && status ){
149     status &= Clusterize(fDigits[ndigits]);
150   }
151   if(! status ) return status;
152
153   // Cluster merging
154   int nclusters0 = fNClusters;
155   while( nclusters0-- ){
156     AliPHOSDATreeCluster& cluster0 = fClusters[nclusters0];
157     int nclusters1 = nclusters0;
158     while( nclusters1-- ){
159       AliPHOSDATreeCluster& cluster1 = fClusters[nclusters1];
160       if( cluster0.IsNeighbor(cluster1) ){
161         cluster0.Append(cluster1);
162         cluster1.Reset();
163       }
164     }
165   }
166   int nclustersnonzero = 0;
167   int nclusters = fNClusters;
168   while( nclusters-- ){
169     fClusters[nclusters].CalculateProperty();
170     if( fClusters[nclusters].GetEnergy()>0 ) nclustersnonzero++;
171   }
172   //std::cout<<" nclustersnonzero = "<<nclustersnonzero<<std::endl;
173   if( nclustersnonzero > 0 ){
174     AliPHOSDATreeCluster* newClusters = new AliPHOSDATreeCluster[nclustersnonzero];
175     nclusters = fNClusters;
176     fNClusters = nclustersnonzero;
177     while( nclusters-- ){
178       if( fClusters[nclusters].GetEnergy()>0 ){
179         newClusters[--nclustersnonzero] = fClusters[nclusters];
180         //std::cout<<"     : "<<nclusters<<" --> "<<nclustersnonzero<<std::endl;
181       }
182     }
183     if( fNClusters>0 ) delete[] fClusters;
184     fClusters = newClusters;
185   } else {
186     if( fNClusters>0 ) delete[] fClusters;
187     fClusters = 0;
188     fNClusters = 0;
189   }
190   return true;
191 }
192 //------------------------------------------------------------------------
193 void AliPHOSDATreeEvent::Print(Option_t *opt) const
194 {
195   // Print Out
196   
197   char* when = ctime(&fTime);
198   std::cout<<" AliPHOSDATreeEvent:: fNDigits = "<<fNDigits<<" fNClusters="<<fNClusters<<" : "<<when;
199   int ndigits = fNDigits;
200   while( ndigits-- ){
201     std::cout<<" =>["<<ndigits<<"] : ";
202     fDigits[ndigits].Print(opt);
203   }
204   int nclusters = fNClusters;
205   while( nclusters-- ){
206     std::cout<<" =>["<<nclusters<<"] : ";
207     fClusters[nclusters].Print(opt);
208   }
209 }
210 //------------------------------------------------------------------------
211 std::ostream& operator<<(std::ostream& out, const AliPHOSDATreeEvent& event){
212   // Print Out
213
214   char* when = ctime(&(event.fTime));
215   out<<" AliPHOSDATreeEvent:: fNClusters="<<event.fNClusters<<" : "<<when;
216   int ndigits = event.fNDigits;
217   while( ndigits-- ){
218     out<<" =>["<<ndigits<<"] : "<<event.fDigits[ndigits];
219     if( ndigits!=0 ) out<<std::endl;
220   }
221   int nclusters = event.fNClusters;
222   while( nclusters-- ){
223     out<<" =>["<<nclusters<<"] : "<<event.fClusters[nclusters];
224     if( nclusters!=0 ) out<<std::endl;
225   }
226   return out;
227 }
228 //------------------------------------------------------------------------