e2070eb9d2e641e43e23865fb827947bd2800707
[u/mrichter/AliRoot.git] / RICH / DataStructures.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 /*
17   $Log$
18 */
19
20
21 #include "DataStructures.h"
22 #include "AliRun.h"
23 #include <TObjArray.h>
24 #include <TParticle.h>
25
26 ClassImp(AliRICHPadHit)
27
28 ClassImp(AliRICHHit)
29     
30 //___________________________________________
31 AliRICHHit::AliRICHHit(Int_t shunt, Int_t track, Int_t *vol, Float_t *hits):
32     AliHit(shunt, track)
33 {
34     fChamber=vol[0];
35     fParticle=hits[0];
36     fX=hits[1];
37     fY=hits[2];
38     fZ=hits[3];
39     fTheta=hits[4];
40     fPhi=hits[5];
41     fTlength=hits[6];
42     fEloss=hits[7];
43     fPHfirst=(Int_t) hits[8];
44     fPHlast=(Int_t) hits[9];
45     fLoss=hits[13];
46     fMomX=hits[14];
47     fMomY=hits[15];
48     fMomZ=hits[16];
49 }
50
51 ClassImp(AliRICHCerenkov)
52 //___________________________________________
53 AliRICHCerenkov::AliRICHCerenkov(Int_t shunt, Int_t track, Int_t *vol, Float_t *hits):
54     AliHit(shunt, track)
55 {
56     fChamber=vol[0];
57     fX=hits[1];
58     fY=hits[2];
59     fZ=hits[3];
60     fTheta=hits[4];
61     fPhi=hits[5];
62     fEloss=hits[7];
63     fPHfirst=(Int_t) hits[8];
64     fPHlast=(Int_t) hits[9];
65     fCMother=Int_t(hits[10]);
66     fIndex = hits[11];
67     fProduction = hits[12];  
68     fLoss=hits[13];
69     fMomX=hits[14];
70     fMomY=hits[15];
71     fMomZ=hits[16];
72 }
73
74 //___________________________________________
75 AliRICHPadHit::AliRICHPadHit(Int_t *clhits)
76 {
77     fHitNumber=clhits[0];
78     fCathode=clhits[1];
79     fQ=clhits[2];
80     fPadX=clhits[3];
81     fPadY=clhits[4];
82     fQpad=clhits[5];
83     fRSec=clhits[6];
84 }
85
86 ClassImp(AliRICHDigit)
87 //_____________________________________________________________________________
88 AliRICHDigit::AliRICHDigit(Int_t *digits)
89 {
90     //
91     // Creates a RICH digit object to be updated
92     //
93     fPadX        = digits[0];
94     fPadY        = digits[1];
95     fSignal      = digits[2];
96     
97 }
98 //_____________________________________________________________________________
99 AliRICHDigit::AliRICHDigit(Int_t *tracks, Int_t *charges, Int_t *digits)
100 {
101     //
102     // Creates a RICH digit object
103     //
104     fPadX        = digits[0];
105     fPadY        = digits[1];
106     fSignal      = digits[2];
107     for(Int_t i=0; i<100; i++) {
108         fTcharges[i]  = charges[i];
109         fTracks[i]    = tracks[i];
110     }
111 }
112
113 ClassImp(AliRICHTransientDigit)
114     
115 //____________________________________________________________________________
116 AliRICHTransientDigit::AliRICHTransientDigit(Int_t ich, Int_t *digits): 
117     AliRICHDigit(digits)
118 {
119     //
120     // Creates a RICH digit list object
121     //
122     
123     fChamber = ich;
124     fTrackList   = new TObjArray;
125     
126 }
127 //_____________________________________________________________________________
128
129
130 ClassImp(AliRICHRawCluster)
131 Int_t AliRICHRawCluster::Compare(TObject *obj)
132 {
133          AliRICHRawCluster *raw=(AliRICHRawCluster *)obj;
134          Float_t y=fY;
135          Float_t yo=raw->fY;
136          if (y>yo) return 1;
137          else if (y<yo) return -1;
138          else return 0;
139
140 }
141
142 Int_t AliRICHRawCluster::
143 BinarySearch(Float_t y, TArrayF coord, Int_t from, Int_t upto)
144 {
145    // Find object using a binary search. Array must first have been sorted.
146    // Search can be limited by setting upto to desired index.
147
148    Int_t low=from, high=upto-1, half;
149    while(high-low>1) {
150         half=(high+low)/2;
151         if(y>coord[half]) low=half;
152         else high=half;
153    }
154    return low;
155 }
156
157 void AliRICHRawCluster::SortMin(Int_t *idx,Float_t *xdarray,Float_t *xarray,Float_t *yarray,Float_t *qarray, Int_t ntr)
158 {
159   //
160   // Get the 3 closest points(cog) one can find on the second cathode 
161   // starting from a given cog on first cathode
162   //
163   
164   //
165   //  Loop over deltax, only 3 times
166   //
167   
168     Float_t xmin;
169     Int_t jmin;
170     Int_t id[3] = {-2,-2,-2};
171     Float_t jx[3] = {0.,0.,0.};
172     Float_t jy[3] = {0.,0.,0.};
173     Float_t jq[3] = {0.,0.,0.};
174     Int_t jid[3] = {-2,-2,-2};
175     Int_t i,j,imax;
176   
177     if (ntr<3) imax=ntr;
178     else imax=3;
179     for(i=0;i<imax;i++){
180         xmin=1001.;
181         jmin=0;
182     
183         for(j=0;j<ntr;j++){
184             if ((i == 1 && j == id[i-1]) 
185                   ||(i == 2 && (j == id[i-1] || j == id[i-2]))) continue;
186            if (TMath::Abs(xdarray[j]) < xmin) {
187               xmin = TMath::Abs(xdarray[j]);
188               jmin=j;
189            }       
190         } // j
191         if (xmin != 1001.) {    
192            id[i]=jmin;
193            jx[i]=xarray[jmin]; 
194            jy[i]=yarray[jmin]; 
195            jq[i]=qarray[jmin]; 
196            jid[i]=idx[jmin];
197         } 
198     
199     }  // i
200   
201     for (i=0;i<3;i++){
202         if (jid[i] == -2) {
203             xarray[i]=1001.;
204             yarray[i]=1001.;
205             qarray[i]=1001.;
206             idx[i]=-1;
207         } else {
208             xarray[i]=jx[i];
209             yarray[i]=jy[i];
210             qarray[i]=jq[i];
211             idx[i]=jid[i];
212         }
213     }
214
215 }
216
217
218 Int_t AliRICHRawCluster::PhysicsContribution()
219 {
220     Int_t iPhys=0;
221     Int_t iBg=0;
222     Int_t iMixed=0;
223     for (Int_t i=0; i<fMultiplicity; i++) {
224         if (fPhysicsMap[i]==2) iPhys++;
225         if (fPhysicsMap[i]==1) iMixed++;
226         if (fPhysicsMap[i]==0) iBg++;
227     }
228     if (iMixed==0 && iBg==0) {
229         return 2;
230     } else if ((iPhys != 0 && iBg !=0) || iMixed != 0) {
231         return 1;
232     } else {
233         return 0;
234     }
235 }
236 //_____________________________________________________________________________
237
238
239 ClassImp(AliRICHRecHit)
240
241
242 //_____________________________________________________________________________
243 AliRICHRecHit::AliRICHRecHit(Int_t id, Float_t *rechit)
244 {
245     //
246     // Creates a RICH rec. hit object
247     //
248     Theta        = rechit[0];
249     Phi          = rechit[1];
250     Omega        = rechit[2];
251     fX           = rechit[3];
252     fY           = rechit[4];
253 }