Cleanup of collisions geometries and headers.
[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( fNDigits > 0 ) delete[] fDigits;
65   fNDigits = evt.fNDigits;
66   if( fNDigits > 0 ){
67     fDigits = new AliPHOSDATreeDigit[fNDigits];
68     int ndigits = fNDigits;
69     while( ndigits-- ){
70       fDigits[ndigits] = evt.fDigits[ndigits];
71     }
72   } else {
73     fDigits = 0;
74   }
75   //
76   if( fNClusters > 0 ) delete[] fClusters;
77   fNClusters = evt.fNClusters;
78   if( fNClusters > 0 ){
79     fClusters = new AliPHOSDATreeCluster[fNClusters];
80     int nclusters = fNClusters;
81     while( nclusters-- ){
82       fClusters[nclusters] = evt.fClusters[nclusters];
83     }
84   } else {
85     fClusters = 0;
86   }
87   return *this;
88 }
89 //------------------------------------------------------------------------
90 bool AliPHOSDATreeEvent::Fill(float energy,int row,int col){
91   // Fill new digit information
92
93   AliPHOSDATreeDigit digit(energy,row,col);
94   return Fill(digit);
95 }
96 //------------------------------------------------------------------------
97 bool AliPHOSDATreeEvent::Fill(AliPHOSDATreeDigit& digit){
98   // Fill new digit information
99
100   AliPHOSDATreeDigit* newDigits = new AliPHOSDATreeDigit[fNDigits+1];
101   int ndigits = fNDigits;
102   newDigits[ndigits] = digit;
103   while( ndigits-- ){
104     newDigits[ndigits] = fDigits[ndigits];
105   }
106   if( fNDigits>0 ) delete[] fDigits;
107   fDigits = newDigits;
108   fNDigits++;
109   return true;
110 }
111 //------------------------------------------------------------------------
112 bool AliPHOSDATreeEvent::Clusterize(AliPHOSDATreeDigit& digit){
113   //Input digit information into clustering
114
115   bool status = false;
116   int nclusters = fNClusters;
117   while( nclusters-- && !status ){
118     if( fClusters[nclusters].IsNeighbor(digit) ){
119       status = fClusters[nclusters].Append(digit);
120     }
121   }
122   //std::cout<<" DEBUGDEBUG:: status = "<<status<<" fNClusters="<<fNClusters<<std::endl;
123   if( !status ){
124     AliPHOSDATreeCluster* newClusters = new AliPHOSDATreeCluster[fNClusters+1];
125     nclusters = fNClusters;
126     status = newClusters[nclusters].Append(digit);
127     while( nclusters-- ){
128       newClusters[nclusters] = fClusters[nclusters];
129     }
130     if( fNClusters>0 ) delete[] fClusters;
131     fClusters = newClusters;
132     fNClusters++;
133   }
134   return status;
135 }
136 //------------------------------------------------------------------------
137 bool AliPHOSDATreeEvent::ExecuteClustering(){
138   // Run clustering algorithm.
139   // With the filled digit information
140   //
141
142   // Loop over all digit information
143   if( fNDigits <= 0 ) return true;
144   bool status = true;
145   int ndigits = fNDigits;
146   while( ndigits-- && status ){
147     status &= Clusterize(fDigits[ndigits]);
148   }
149   if(! status ) return status;
150
151   // Cluster merging
152   int nclusters0 = fNClusters;
153   while( nclusters0-- ){
154     AliPHOSDATreeCluster& cluster0 = fClusters[nclusters0];
155     int nclusters1 = nclusters0;
156     while( nclusters1-- ){
157       AliPHOSDATreeCluster& cluster1 = fClusters[nclusters1];
158       if( cluster0.IsNeighbor(cluster1) ){
159         cluster0.Append(cluster1);
160         cluster1.Reset();
161       }
162     }
163   }
164   int nclustersnonzero = 0;
165   int nclusters = fNClusters;
166   while( nclusters-- ){
167     fClusters[nclusters].CalculateProperty();
168     if( fClusters[nclusters].GetEnergy()>0 ) nclustersnonzero++;
169   }
170   //std::cout<<" nclustersnonzero = "<<nclustersnonzero<<std::endl;
171   if( nclustersnonzero > 0 ){
172     AliPHOSDATreeCluster* newClusters = new AliPHOSDATreeCluster[nclustersnonzero];
173     nclusters = fNClusters;
174     fNClusters = nclustersnonzero;
175     while( nclusters-- ){
176       if( fClusters[nclusters].GetEnergy()>0 ){
177         newClusters[--nclustersnonzero] = fClusters[nclusters];
178         //std::cout<<"     : "<<nclusters<<" --> "<<nclustersnonzero<<std::endl;
179       }
180     }
181     if( fNClusters>0 ) delete[] fClusters;
182     fClusters = newClusters;
183   } else {
184     if( fNClusters>0 ) delete[] fClusters;
185     fClusters = 0;
186     fNClusters = 0;
187   }
188   return true;
189 }
190 //------------------------------------------------------------------------
191 void AliPHOSDATreeEvent::Print(Option_t *opt) const
192 {
193   // Print Out
194   
195   char* when = ctime(&fTime);
196   std::cout<<" AliPHOSDATreeEvent:: fNDigits = "<<fNDigits<<" fNClusters="<<fNClusters<<" : "<<when;
197   int ndigits = fNDigits;
198   while( ndigits-- ){
199     std::cout<<" =>["<<ndigits<<"] : ";
200     fDigits[ndigits].Print(opt);
201   }
202   int nclusters = fNClusters;
203   while( nclusters-- ){
204     std::cout<<" =>["<<nclusters<<"] : ";
205     fClusters[nclusters].Print(opt);
206   }
207 }
208 //------------------------------------------------------------------------
209 std::ostream& operator<<(std::ostream& out, const AliPHOSDATreeEvent& event){
210   // Print Out
211
212   char* when = ctime(&(event.fTime));
213   out<<" AliPHOSDATreeEvent:: fNClusters="<<event.fNClusters<<" : "<<when;
214   int ndigits = event.fNDigits;
215   while( ndigits-- ){
216     out<<" =>["<<ndigits<<"] : "<<event.fDigits[ndigits];
217     if( ndigits!=0 ) out<<std::endl;
218   }
219   int nclusters = event.fNClusters;
220   while( nclusters-- ){
221     out<<" =>["<<nclusters<<"] : "<<event.fClusters[nclusters];
222     if( nclusters!=0 ) out<<std::endl;
223   }
224   return out;
225 }
226 //------------------------------------------------------------------------